Add files using upload-large-folder tool

parse/train/BJlguT4YPr/BJlguT4YPr.md

@@ -0,0 +1,420 @@
+# SCALABLE NEURAL METHODS FOR REASONING WITH A SYMBOLIC KNOWLEDGE BASE
+
+William W. Cohen & Haitian Sun & R. Alex Hofer & Matthew Siegler Google, Inc {wcohen,haitiansun,rofer,msiegler}@google.com
+
+# ABSTRACT
+
+We describe a novel way of representing a symbolic knowledge base (KB) called a sparse-matrix reified $K B$ . This representation enables neural KB inference modules that are fully differentiable, faithful to the original semantics of the KB, expressive enough to model multi-hop inferences, and scalable enough to use with realistically large KBs. The sparse-matrix reified KB can be distributed across multiple GPUs, can scale to tens of millions of entities and facts, and is orders of magnitude faster than naive sparse-matrix implementations. The reified KB enables very simple end-to-end architectures to obtain competitive performance on several benchmarks representing two families of tasks: KB completion, and learning semantic parsers from denotations.
+
+# 1 INTRODUCTION
+
+There has been much prior work on using neural networks to generalize the contents of a KB (Xiong et al., 2017; Bordes et al., 2013; Dettmers et al., 2018), typically by constructing low-dimensional embeddings of the entities and relations in the KB, which are then used to score potential triples as plausible or implausible elements of the KB. We consider here the related but different problem of incorporating a symbolic KB into a neural system, so as to inject knowledge from an existing KB directly into a neural model. More precisely, we consider the problem of designing neural KB inference modules that are (1) fully differentiable, so that any loss based on their outputs can be backpropagated to their inputs; (2) accurate, in that they are faithful to the original semantics of the KB; (3) expressive, so they can perform non-trivial inferences; and (4) scalable, so that realistically large KBs can be incorporated into a neural model.
+
+To motivate the goal of incorporating a symbolic KB into a neural network, consider the task of learning neural semantic parsers from denotations. Many questions—e.g., what’s the most recent movie that Quentin Tarantino directed? or which nearby restaurants have vegetarian entrees and take reservations?—are best answered by knowledge-based question-answering (KBQA) methods, where an answer is found by accessing a KB. Within KBQA, a common approach is neural semantic parsing—i.e., using neural methods to translate a natural-language question into a structured query against the KB (Zhong et al., 2017; Finegan-Dollak et al., 2018; Shaw et al., 2019), which is subsequently executed with a symbolic KB query engine. While this approach can be effective, it requires training data pairing natural-language questions with structured queries, which is difficult to obtain. Hence researchers have also considered learning semantic parsers from denotations (Berant et al., 2013; Yih et al., 2015), where training data consists of pairs $( q , A )$ , where $q$ is a natural-language question and $A$ is the desired answer. Typically $A$ is a set of KB entities—e.g., if $q$ is the first sample question above, $A$ would be1 the singleton set containing Once Upon a Time in Hollywood.
+
+Learning semantic parsers from denotations is difficult because the end-to-end process to be learned includes a non-differentiable operation—i.e., reasoning with the symbolic KB that contains the answers. To circumvent this difficulty, prior systems have used three different approaches. Some have used heuristic search to infer structured queries from denotations (Pasupat & Liang, 2016; Dasigi et al., 2019): this works in some cases but often an answer could be associated with many possible structured queries, introducing noise. Others have supplemented gradient approaches with $x$ : an entity $X$ : weighted set of entities x: vector encoding $X$ $N _ { E }$ : # entities in KB $r$ : an relation $R$ : weighted set of relations r: vector encoding $R$ $N _ { R }$ : # relations in KB ${ { \bf { M } } _ { r } }$ : matrix for $r$ ${ \bf { M } } _ { R }$ : weighted sum of ${ { \bf { M } } _ { r } }$ ’s, see Eq 1 $f o l l o w ( \mathbf { x } , \mathbf { r } )$ : see Eq 2 $N _ { T }$ : # triples in KB $\mathbf { M } _ { s u b j }$ $\mathbf { \tau } _ { s u b j } , \mathbf { M } _ { o b j } , \mathbf { M } _ { r e l }$ : the reified KB, encoded as matrices mapping triple id $\ell$ to subject, object, and relation ids
+
+Table 1: Summary of notation used in the paper. (This excludes notation used in defining models for the KB completion and QA tasks of Section 3.)
+
+reinforcement learning (e.g., (Misra et al., 2018)). Some systems have also “neuralized” KB reasoning, but to date only over small KBs: this approach is natural when answers are naturally constrained to depend on a small set of facts (e.g., a single table (Zhong et al., 2017; Gupta & Lewis, 2018)), but more generally requires coupling a learner with some (non-differentiable) mechanism to retrieve an appropriate small question-dependent subset of the KB as in (Sun et al., 2018; 2019).
+
+In this paper, we introduce a novel scheme for incorporating reasoning on a large question-independent KB into a neural network, by representing a symbolic KB with an encoding called a sparse-matrix reified KB. A sparse-matrix reified KB is very compact, can be distributed across multiple GPUs if necessary, and is well-suited to modern GPU architecture. For KBs with many relations, a reified KB can be up to four orders of magnitude faster than alternative implementations (even alternatives based on sparse-matrix representations), and in our experiments we demonstrate scalability to a KB with over 13 million entities and nearly 44 million facts. This new architectural component leads to radically simpler architectures for neural semantic parsing from denotations—architectures based on a single end-to-end differentiable process, rather than cascades of retrieval and neural processes.
+
+We show that very simple instantiations of these architectures are still highly competitive with the state of the art for several benchmark tasks. To our knowledge these models are the first fully end-to-end neural parsers from denotations that have been applied to these benchmark tasks. We also demonstrate that these architectures scale to long chains of reasoning on synthetic tasks, and demonstrate similarly simple architectures for a second task, KB completion.
+
+# 2 NEURAL REASONING WITH A SYMBOLIC KB
+
+# 2.1 BACKGROUND
+
+KBs, entities, and relations. A KB consists of entities and relations. We use $x$ to denote an entity and $r$ to denote a relation. Each entity has an integer index between 1 and $N _ { E }$ , where $N _ { E }$ is the number of entities in the KB, and we write $x _ { i }$ for the entity that has index $i$ . A relation is a set of entity pairs, and represents a relationship between entities: for instance, if $x _ { i }$ represents “Quentin Tarantino” and $x _ { j }$ represents “Pulp Fiction” then $( x _ { i } , x _ { j } )$ would be an member of the relation director_of. A relation $r$ can thus be represented as a subset of $\left\{ 1 , \dots , N _ { E } \right\} \times \left\{ 1 , \dots , N _ { E } \right\}$ . Finally a KB consists a set of relations and a set of entities.
+
+Weighted sets as $^ { 6 6 } k$ -hot” vectors. Our differentiable operations are based on weighted sets, where each element $x$ of weighted set $X$ is associated with a non-negative real number. It is convenient to define this weight to be zero for all $x \not \in X$ , while for $x \in X$ , a weight less than 1 is a confidence that the set contains $x$ , and weights more than 1 make $X$ a multiset. If all elements of $X$ have weight 1, we say $X$ is a hard set. A weighted set $X$ can be encoded as an entity-set vector $\mathbf { x } \in \mathbb { R } ^ { N _ { E } }$ , where the $i$ -th component of $\mathbf { X }$ is the weight of $x _ { i }$ in $X$ . If $X$ is a hard entity set, then this will be a “ $k$ -hot” vector, for $k = | X |$ . The set of indices of $\mathbf { X }$ with non-zero values is called the support of $\dot { \boldsymbol { x } }$ .
+
+Sets of relations, and relations as matrices Often we would like to reason about sets of relations2, so we also assume every relation $r$ in a KB is associated with an entity and hence an integer index. We write $r _ { k }$ for the relation with index $k$ , and we assume that relation entities are listed first in the index of entities, so the index $k$ for $r _ { k }$ is between 1 and $N _ { R }$ , where $N _ { R }$ is the number of relations in the KB. We use $R$ for a set of relations, e.g., $R = \{ w r i t e r \_ o f , d i r e c t o r \_ o f \}$ might be such a set, and use $\mathbf { r }$ for a vector encoding of a set. A relation $r$ can be encoded as a relation matrix $\mathbf { M } _ { r } \in \mathbb { R } ^ { N _ { E } \times N _ { E } }$ , where the value for $\mathbf { M } _ { r } [ i , j ]$ is (in general) the weight of the assertion $r ( x _ { i } , x _ { j } )$ in the KB. In the experiments of this paper, all KB relations are hard sets, so $\mathbf { M } _ { r } [ i , j ] \in \{ 0 , 1 \}$ .
+
+Sparse vs. dense matrices for relations. Scalably representing a large KB requires careful consideration of the implementation. One important issue is that for all but the smallest KBs, a relation matrix must be implemented using a sparse matrix data structure, as explicitly storing all $N _ { E } ^ { 2 }$ values is impractical. For instance, consider a KB containing 10,000 movie entities and 100,000 person entities. A relationship like writer_of would have only a few tens of thousands of facts (since most movies have only one or two writers), but a dense matrix would have 1 billion values.
+
+We thus model relations as sparse matrices. Let $N _ { r }$ be the number of entity pairs in the relation $r$ : common sparse matrix data structures require space $O ( N _ { r } )$ . One common sparse matrix data structure is a sparse coordinate pair $( C O O )$ encoding: with a COO encoding, each KB fact requires storing only two integers and one float.
+
+Our implementations are based on Tensorflow (Abadi et al., 2016), which offers limited support for sparse matrices. In particular, driven by the limitations of GPU architecture, Tensorflow only supports matrix multiplication between a sparse matrix COO and a dense matrix, but not between two sparse matrices, or between sparse higher-rank tensors and dense tensors.
+
+Entity types. It is often possible to easily group entities into disjoint sets by some notion of “type”: for example, in a movie domain, all entities might be either of the type “movie”, “person”, or “movie studio”. It is straightforward to extend the formalism above to typed sets of entities, and doing this can lead to some useful optimizations. We use these optimizations below where appropriate: in particular, relation-set vectors r are of dimension $N _ { R }$ , not $N _ { E }$ , in the sections below. The full formal extension to typed entities and relations is given in Appendix A.
+
+# 2.2 REASONING IN A KB
+
+The relation-set following operation. Note that relations can also be viewed as labeled edges in a knowledge graph, the vertices of which are entities. Adopting this view, we define the $r$ - neighbors of an entity $x _ { i }$ to be the set of entities $x _ { j }$ that are connected to $x _ { i }$ by an edge labeled $r$ , i.e., $r$ - ${ \cdot } n e i g h b o r s ( x ) \equiv \left\{ x _ { j } : ( x _ { i } , x _ { j } ) \in r \right\}$ . Extending this to relation sets, we define
+
+$$
+R \neg n e i g h b o r s ( X ) \equiv \left\{ x _ { j } : \exists r \in R , x _ { i } \in X \mathrm { ~ s o ~ t h a t ~ } ( x _ { i } , x _ { j } ) \in r \right\}
+$$
+
+Computing the $R$ -neighbors of an entity is a single-step reasoning operation: e.g., the answer to the question q =“what movies were produced or directed by Quentin Tarantino” is precisely the set $R$ -neighbors $( X )$ for $R = \{ p r o d u c e r \_ o f , w r i t e r \_ o f \}$ and $X = \{ Q u e n t i n \_ T a r a n t i n o \}$ . “Multi-hop” reasoning operations require nested $R$ -neighborhoods, e.g. if $R ^ { \prime } = \{ a c t o r { \_ } o f \}$ then $R ^ { \prime }$ -neighbors $R$ - neighbors $( X )$ ) is the set of actors in movies produced or directed by Quentin Tarantino.
+
+We would like to approximate the $R$ -neighbors computation with differentiable operations that can be performed on the vectors encoding the sets $X$ and $R$ . Let $\mathbf { X }$ encode a weighted set of entities $X$ , and let r encode a weighted set of relations. We first define $\mathbf { M } _ { R }$ to be a weighted mixture of the relation matrices for all relations in $R$ i.e.,
+
+$$
+\mathbf { M } _ { R } \equiv ( \sum _ { k = 1 } ^ { N _ { R } } \mathbf { r } [ k ] \cdot \mathbf { M } _ { r _ { k } } )
+$$
+
+We then define the relation-set following operation for $\boldsymbol { x }$ and $r$ as:
+
+$$
+f o l l o w ( \mathbf { x } , \mathbf { r } ) \equiv \mathbf { x } \mathbf { M } _ { R } = \mathbf { x } ( \sum _ { k = 1 } ^ { N _ { R } } \mathbf { r } [ k ] \cdot \mathbf { M } _ { r _ { k } } )
+$$
+
+As we will show below, this differentiable numerical relation-set following operation can be used as a neural component to perform certain types of logical reasoning. In particular, $\operatorname { E q } 2$ corresponds closely to the logical $R$ -neighborhood operation, as shown by the claim below.
+
+Claim 1 The support of follow $\scriptstyle ( \mathbf { x } , \pmb { r } )$ is exactly the set of $R$ -neighbors( $X )$ .
+
+A proof and the implications of this are discussed in Appendix B.
+
+# 2.3 SCALABLE RELATION-SET FOLLOWING WITH A REIFIED KB
+
+Baseline implementations. Suppose the KB contains $N _ { R }$ relations, $N _ { E }$ entities, and $N _ { T }$ triples. Typically $\hat { N _ { R } } < \hat { N _ { E } } < \hat { N _ { T } } \ll \hat { N _ { E } ^ { 2 } }$ . As noted above, we implement each ${ { \bf { M } } _ { r } }$ as a sparse COO matrix,
+
+<table><tr><td rowspan="2">Strategy</td><td rowspan="2">Definition</td><td rowspan="2">Batch?</td><td rowspan="2">Space complexity</td><td colspan="3"># Operations</td></tr><tr><td>sp-dense matmul</td><td>dense +or ⊙</td><td>sparse +</td></tr><tr><td>naive mixing</td><td>Eq 1-2</td><td>no</td><td>O(Nr+NE+NR)</td><td>1</td><td>0</td><td>NR</td></tr><tr><td>late mixing</td><td>Eq3</td><td>yes</td><td>O(NT +bNE +bNR)</td><td>NR</td><td>NR</td><td>0</td></tr><tr><td>reified KB</td><td>Eq 4</td><td>yes</td><td>O(bNr+bNE)</td><td>3</td><td>1</td><td>0</td></tr></table>
+
+Table 2: Complexity of implementations of relation-set following, where $N _ { T }$ is the number of KB triples, $N _ { E }$ the number of entities, $N _ { R }$ the number of relations, and $b$ is batch size.
+
+so collectively these matrices require space $O ( N _ { T } )$ . Each triple appears in only one relation, so $\mathbf { M } _ { R }$ in Eq 1 is also size $O ( N _ { T } )$ . Since sparse-sparse matrix multiplication is not supported in Tensorflow we implement $\mathbf { x M } _ { R }$ using dense-sparse multiplication, so $\mathbf { X }$ must be a dense vector of size $O ( N _ { E } )$ , as is the output of relation-set following. Thus the space complexity of $f o l l o w ( \mathbf { x } , \mathbf { r } )$ is $O ( N _ { T } + N _ { E } + N _ { R } )$ , if implemented as suggested by $\operatorname { E q } 2$ . We call this the naive mixing implementation, and its complexity is summarized in Table 2.
+
+Because Tensorflow does not support general sparse tensor contractions, it is not always possible to extend sparse-matrix computations to minibatches. Thus we also consider a variant of naive mixing called late mixing, which mixes the output of many single-relation following steps, rather than mixing the KB itself:
+
+$$
+f o l l o w ( \mathbf { x } , \mathbf { r } ) = \sum _ { k = 1 } ^ { N _ { R } } ( \mathbf { r } [ k ] \cdot \mathbf { x } \mathbf { M } _ { r _ { k } } )
+$$
+
+Unlike naive mixing, late mixing can be extended easily to a minibatches (see Appendix C). Let $b$ be the batch size and $\mathbf { X }$ be a minibatch of $b$ examples $\left[ \mathbf { x } _ { 1 } ; \ldots ; \mathbf { x } _ { b } \right]$ : then this approach leads to $N _ { R }$ matrices $\mathbf { X M } _ { k }$ , each of size $O ( b N _ { E } )$ . However, they need not all be stored at once, so the space complexity becomes $O ( b N _ { E } + b N _ { R } + N _ { T } )$ . An additional cost of late mixing is that we must now sum up $N _ { R }$ dense matrices.
+
+A reified knowledge base. While semantic parses for natural questions often use small sets of relations (often singleton ones), in learning there is substantial uncertainty about what the members of these small sets should be. Furthermore, realistic wide-coverage KBs have many relations—typically hundreds or thousands. This leads to a situation where, at least during early phases of learning, it is necessary to evaluate the result of mixing very large sets of relations. When many relations are mixed, late mixing becomes quite expensive (as experiments below show).
+
+An alternative is to represent each KB assertion $r _ { k } ( x _ { i } , x _ { j } )$ as a tuple $( i , j , k )$ where $i , j , k$ are the indices of $x _ { i } , x _ { j }$ , and $r _ { k }$ . There are $N _ { T }$ such triples, so for $\ell = 1 , \ldots , N _ { T }$ , let $( i _ { \ell } , j _ { \ell } , k _ { \ell } )$ denote the $\ell \cdot$ -th triple. We define these sparse matrices:
+
+$$
+\mathbf { M } _ { s u b j } [ \ell , m ] \equiv \left\{ \begin{array} { l l } { 1 \mathrm { ~ i f ~ } m = i \ell } &  \mathbf { M } _ { o b j } [ \ell , m ] \equiv \left\{ \begin{array} { l l } { 1 \mathrm { ~ i f ~ } m = j \ell } & { \mathbf { M } _ { r e l } [ \ell , m ] \equiv \left\{ \begin{array} { l l } { 1 \mathrm { ~ i f ~ } m = k _ { \ell } } \\ { 0 \mathrm { ~ e l s e ~ } } & { } \end{array} \right. \right. } \end{array} \right. \end{array}
+$$
+
+Conceptually, $\mathbf { M } _ { s u b j }$ maps the index $\ell$ of the $\ell$ -th triple to its subject entity; $\mathbf { M } _ { o b j }$ maps $\ell$ to the object entity; and ${ { \bf { M } } _ { r e l } }$ maps $\ell$ to the relation. We can now implement the relation-set following as below, where $\odot$ is Hadamard product:
+
+$$
+f o l l o w \mathbf { ( x , r ) } = ( \mathbf { x M } _ { s u b j } ^ { T } \odot \mathbf { r M } _ { r e l } ^ { T } ) \mathbf { M } _ { o b j }
+$$
+
+Notice that $\mathbf { x M } _ { s u b j } ^ { T }$ are the triples with an entity in $\mathbf { X }$ as their subject, $\mathbf { r } \mathbf { M } _ { r e l } ^ { T }$ are the triples with a relation in $\mathbf { r }$ , and the Hadamard product is the intersection of these. The final multiplication by $\mathbf { M } _ { o b j }$ finds the object entities of the triples in the intersection. These operations naturally extend to minibatches (see Appendix). The reified KB has size $O ( N _ { T } )$ , the sets of triples that are intersected have size $O ( b N _ { T } )$ , and the final result is size $O ( b N _ { E } )$ , giving a final size of $O ( b N _ { T } + b N _ { E } )$ , with no dependence on $N _ { R }$ .
+
+Table 2 summarizes the complexity of these three mathematically equivalent but computationally different implementions. The analysis suggests that the reified KB is preferable if there are many relations, which is the case for most realistic ${ \mathrm { K B s } } ^ { 3 }$ .
+
+![](images/72604657a9eb5648313f468d1b90fc0311598bfc947064885ae8c79e2eab68cd.jpg)  
+Figure 1: Left and middle: inference time in queries/sec on a synthetic KB as size and number of relations is varied. Queries/sec is given as zero when GPU memory of 12Gb is exceeded. Right: speedups of reified KBs over the baseline implementations.
+
+Distributing a large reified KB. The reified KB representation is quite compact, using only six integers and three floats for each KB triple. However, since GPU memory is often limited, it is important to be able to distribute a KB across multiple GPUs. Although to our knowledge prior implementations of distributed matrix operations (e.g., (Shazeer et al., 2018)) do not support sparse matrices, sparse-dense matrix multiplication can be distributed across multiple machines. We thus implemented a distributed sparse-matrix implementation of reified $K B s$ . We distibuted the matrices that define a reified KB “horizontally”, so that different triple ids $\ell$ are stored on different GPUs. Details are provided in Appendix D.
+
+# 3 EXPERIMENTS
+
+# 3.1 SCALABILITY
+
+Like prior work (Cohen et al., 2017; De Raedt et al., 2007), we used a synthetic KB based on an $n$ -by- $\mathbf { \nabla } \cdot n$ grid to study scalability of inference. Every grid cell is an entity, related to its immediate neighbors via relations north, south, east, and west. The KB for an $n$ -by- $^ n$ grid thus has $O ( n ^ { 2 } )$ entities and $O ( n ^ { 2 } )$ triples. We measured the time to compute the 2-hop inference follow $( f o l l o w ( \mathbf { x } , \mathbf { r } ) , \mathbf { r } )$ for minibatches of $b = 1 2 8$ one-hot vectors, and report it as queries per second (qps) on a single GPU (e.g., $\mathrm { \ q p s { = } 1 } 2 8 0$ would mean a single minibatch requires $1 0 0 \mathrm { m s }$ ). We also compare to a key-value memory network (Miller et al., 2016), using an embedding size of 64 for entities and relations, where there is one memory entry for every triple in the KB. Further details are given in Appendix E.
+
+The results are shown Figure 1 (left and middle), on a log-log scale because some differences are very large. With only four relations (the leftmost plot), late mixing is about $3 \mathbf { x }$ faster than the reified KB method, and about $2 5 0 \mathrm { x }$ faster than the naive approach. However, for more than around 20 relations, the reified KB is faster (middle plot). As shown in the rightmost plot, the reified KB is $5 0 \mathrm { x }$ faster than late mixing with 1000 relations, and nearly $1 2 { , } 0 0 0 \mathrm { x }$ faster than the naive approach.
+
+With this embedding size, the speed of the key-value network is similar to the reified KB for only four relations, however it is about $7 \mathbf { x }$ slower for 50 relations and 10k entities. Additionally, the space needed to store a triple is much larger in a key-value network than the reified KB, so memory is exhausted when the KB exceeds 200,000 entities (with four relations), or when the KB exceeds 100 relations (with 10,000 entities.) The reified KB scales much better, and can handle $1 0 \mathrm { x }$ as many entities and $2 0 \mathrm { x }$ as many relations.
+
+# 3.2 MODELS USING REIFIED KBS
+
+As discussed below in Section 4, the reified KB is closely related to key-value memory networks, so it can be viewed as a more efficient implementation of existing neural modules, optimized for reasoning with symbolic KBs. However, being able to include an entire KB into a model can lead to a qualitative difference in model complexity, since it is not necessary to build machinery to retrieve from the KB. To illustrate this, below we present simple models for several tasks, each using the reified KB in different ways, as appropriate to the task. We consider two families of tasks: learning semantic parsers from denotations over a large KB, and learning to complete a KB.
+
+KBQA for multi-hop questions. MetaQA (Zhang et al., 2018) consists of 1.2M questions, evenly distributed into one-hop, two-hop, and three-hop questions. (E.g, the question “who acted in a movie directed by Quentin Tarantino?” is a two-hop question.) The accompanying KB (Miller et al., 2016) contains 43k entities and 186k triples. Past work treated one-hop, two-hop and three-hop questions separately, and the questions are labeled with the entity ids for the “seed entities” that begin the reasoning chains (e.g., the question above would be tagged with the id of the entity for Quentin Tarantino).
+
+Using a reified KB for reasoning means the neural model only needs to predict the relations used at each stage in the reasoning process. For each step of inference we thus compute relation sets $\mathbf { r } ^ { t }$ using a differentiable function of the question, and then chain them together with relation-set following steps. Letting $\mathbf { x } ^ { 0 }$ be the set of entities associated with $q$ , the model we use is:
+
+$$
+\mathrm { f o r } t = 1 , 2 , 3 ; ~ { \bf r } ^ { t } = f ^ { t } ( q ) ; ~ { \bf x } ^ { t } = f o l l o w ( { \bf x } ^ { t - 1 } , { \bf r } ^ { t } )
+$$
+
+where follow $\left( \mathbf { x } ^ { t - 1 } , \mathbf { r } ^ { t } \right)$ is implemented with a reified KB as described in Eq. 4.
+
+To predict an answer on a $T$ -hop subtask, we compute the softmax of the appropriate set $\mathbf { x } ^ { T }$ . We used cross entropy loss of this set against the desired answer, represented as a uniform distribution over entities in the target set. Each function $f ^ { t } ( q )$ is a different linear projection of a common encoding for $q$ , specifically a mean-pooling of the tokens in $q$ encoded with a pre-trained 128-dimensional word2vec model (Mikolov et al., 2013). The full KB was loaded into a single GPU in our experiments.
+
+It is interesting to contrast this simple model with the one proposed by Zhang et al. (2018). The “module for logic reasoning” they propose in Section 3.4 is fairly complex, with a description that requires a figure, three equations, and a page of text; furthermore, training this model requires constructing an example-dependent subgraph for each training instance. In our model, the “logic reasoning” (and all interaction with the KB) has been encapsulated completely in the $\ell o l l o w ( \mathbf { x } , \mathbf { r } )$ operation—which, as we will demonstrate below, can be re-used for many other problems. Encapsulating all KB reasoning with a single scalable differentiable neural module greatly simplifies modeling: in particular, the problem of learning a structured KB query has been reduced to learning a few differentiable functions of the question, one for each reasoning “hop”. The learned functions are also interpretable: they are mixtures of relation identifiers which correspond to soft weighted sets of relations, which in turn softly specify which KB relation should be used in each stage of the reasoning process. Finally, optimization is simple, as the loss on predicted denotations can be back-propagated to the relation-prediction functions.
+
+A similar modeling strategy is used in all the other models presented below.
+
+KBQA on FreeBase. WebQuestionsSP (Yih et al., 2016) contains 4737 natural language questions, all of which are answerable using FreeBase (Bollacker et al., 2008), a large open-domain KB. Each question $q$ is again labeled with the entities $\mathbf { X }$ that appear in it.
+
+FreeBase contains two kinds of nodes: real-world entities, and compound value types (CVTs), which represent non-binary relationships or events (e.g., a movie release event, which includes a movie id, a date, and a place.) Real-world entity nodes can be related to each other or to a CVT node, but CVT nodes are never directly related to each other. In this dataset, all questions can be answered with 1- or 2-hop chains, and all 2-hop reasoning chains pass through a CVT entity; however, unlike MetaQA, the number of hops is not known. Our model thus derives from $q$ three relation sets and then uniformly mixes both potential types of inferences:
+
+$$
+\begin{array} { r l } & { \mathbf { r } _ { \mathrm { E  E } } = f _ { \mathrm { E  E } } ( q ) ; \mathbf { r } _ { \mathrm { E  C V T } } = f _ { \mathrm { E  C V T } } ( q ) ; \mathbf { r } _ { \mathrm { C V T  E } } = f _ { \mathrm { C V T  E } } ( q ) } \\ & { \qquad \hat { \mathbf { a } } = f o l l o w ( f o l l o w ( \mathbf { x } , \mathbf { r } _ { \mathrm { E  C V T } } ) , \mathbf { r } _ { \mathrm { C V T  E } } ) + f o l l o w ( \mathbf { x } , \mathbf { r } _ { \mathrm { E  E } } ) } \end{array}
+$$
+
+We again apply a softmax to $\hat { \mathbf { a } }$ and use cross entropy loss, and $f _ { \mathrm { E \to E } }$ , $f _ { \mathrm { E  C V T } }$ , and $f _ { \mathrm { C V T  E } }$ are again linear projections of a word2vec encoding of $q$ . We used a subset of Freebase with 43.7 million facts and 12.9 million entities, containing all facts in Freebase within 2-hops of entities mentioned in any question, excluding paths through some very common entities. We split the KB across three 12-Gb GPUs, and used a fourth GPU for the rest of the model.
+
+This dataset is a good illustration of the scalability issues associated with prior approaches to including a KB in a model, such as key-value memory networks. A key-value network can be trained to implement something similar to relation-set following, if it stores all the KB triples in memory. If we assume 64-float embeddings for the 12.9M entities, the full KB of 43.7M facts would be 67Gb in size, which is impractical. Additionally performing a softmax over the 43.7M keys would be prohibitively expensive, as shown by the experiments of Figure 1. This is the reason why in standard practice with key-value memory networks for KBs, the memory is populated with a heuristically subset of the KB, rather than the full KB. We compare experimentally to this approach in Table 3.
+
+Knowledge base completion. Following Yang et al. (2017) we treat KB completion as an inference task, analogous to KBQA: a query $q$ is a relation name and a head entity $\mathbf { X }$ , and from this we predict a set of tail entities. We assume the answers are computed with the disjunction of multiple inference chains of varying length. Each inference chain has a maximum length of $T$ and we build $N$ distinct inference chains in total, using this model (where $\mathbf { x } _ { i } ^ { 0 } = \mathbf { x }$ for every chain $\romannumeral 1$ ):
+
+$$
+\mathrm { o r } i = 1 , \dots , N \mathrm { ~ a n d ~ } t = 1 , \dots , T ; \quad \mathbf { r } _ { i } ^ { t } = f _ { i } ^ { t } ( q ) ; \quad \mathbf { x } _ { i } ^ { t } = f o l l o w ( \mathbf { x } _ { i } ^ { t - 1 } , \mathbf { r } _ { i } ^ { t } ) + \mathbf { x } _ { i } ^ { t - 1 }
+$$
+
+The final output is a softmax of the mix of all the $\mathbf { x } _ { i } ^ { T }$ ’s: i.e., we let $\begin{array} { r } { \hat { \mathbf { a } } = s o f t m a x ( \sum _ { i \in \{ 1 \ldots N \} } \mathbf { x } _ { i } ^ { T } ) } \end{array}$ . The update $\mathbf { x } _ { i } ^ { t + 1 } = f o l l o w ( \mathbf { x } _ { i } ^ { t } , \mathbf { r } _ { i } ^ { t } ) + \mathbf { x } _ { i } ^ { t }$ gives the model access to outputs of all chains of length less than $t$ (for more intuition see Appendix E.) The encoding of $q$ is based on a lookup table, and each $f _ { i } ^ { t }$ is a learned linear transformation of $q$ ’s embedding.4
+
+An encoder-decoder architecture for varying inferential structures. To explore performance on more complex reasoning tasks, we generated simple artificial natural-language sentences describing longer chains of relationships on a 10-by-10 grid. For this task we used an encoder-decoder model which emits chains of relation-set following operations. The question is encoded with the final hidden state of an LSTM, written here $ { \mathbf { h } } ^ { 0 }$ . We then generate a reasoning chain of length up to $T$ using a decoder LSTM. At iteration $t$ , the decoder emits a scalar probability of “stopping”, $p ^ { t }$ , and a distribution over relations to follow $\mathbf { r } ^ { t }$ , and then, as we did for the KBQA tasks, sets $\mathbf { \bar { x } } ^ { t } = f o l l o w ( \mathbf { x } ^ { t - 1 } , \mathbf { r } ^ { t } )$ . Finally the decoder updates its hidden state to $\mathbf { h } ^ { t }$ using an LSTM cell that “reads” the “input” $\mathbf { r } ^ { i - 1 }$ . For each step $t$ , the model thus contains the steps
+
+$$
+p ^ { t } = f _ { p } ( \mathbf { h } ^ { t - 1 } ) ; ~ \mathbf { r } ^ { t } = f _ { r } ( \mathbf { h } ^ { t - 1 } ) ; ~ \mathbf { x } ^ { t } = f o l l o w ( \mathbf { x } ^ { t - 1 } , \mathbf { r } ^ { t } ) ; ~ \mathbf { h } ^ { t } = \mathrm { L S T M } ( \mathbf { h } ^ { t - 1 } , \mathbf { r } ^ { t - 1 } )
+$$
+
+The final predicted location is a mixture of all the $\mathbf { X } _ { t }$ ’s weighted by the probability of stopping $p _ { t }$ at iteration $t$ , i.e., $\begin{array} { r } { \hat { \mathbf { a } } = s o f t m a x ( \sum _ { t = 1 } ^ { T } \mathbf { x } ^ { t } \cdot p ^ { t } \prod _ { t ^ { \prime } < t } ( 1 - p ^ { t ^ { \prime } } ) ) } \end{array}$ . The function $f _ { r }$ is a softmax over a linear projection, and $f _ { p }$ is a logistic function. In the experiments, we trained on 360,000 sentences requiring between 1 and $T$ hops and tested on an additional 12,000 sentences.
+
+Experimental results. We next consider the performance of these models relative to strong baselines for each task. We emphasize our goal here is not to challenge the current state of the art on any particular benchmark, and clearly there are many ways the models of this paper could be improved. (For instance, our question encodings are based on word2vec, rather than contextual encodings (Devlin et al., 2018), and likewise relations are predicted with simple linear classifiers, rather than, say, attention queries over some semantically meaningful space, such as might be produced with language models or KB embedding approaches (Bordes et al., 2013)). Rather, our contribution is to present a generally useful scheme for including symbolic KB reasoning into a model, and we have thus focused on describing simple, easily understood models that do this for several tasks. However, it is important to confirm experimentally that the reified KB models “work”—e.g., that they are amenable to use of standard optimizers, etc.
+
+Performance (using Hits $@ .$ 1) of our models on the KBQA tasks is shown in Table 3. For the nonsynthetic tasks we also compare to a Key-Value Memory Network (KV-Mem) baseline (Miller et al., 2016). For the smaller MetaQA dataset, KV-Mem is initialized with all facts within 3 hops of the query entities, and for WebQuestionsSP it is initialized by a random-walk process seeded by the query entities (see (Sun et al., 2018; Zhang et al., 2018) for details). ReifKB consistently outperforms the baseline, dramatically so for longer reasoning chains. The synthetic grid task shows that there is very little degradation as chain length increases, with $\mathrm { H i t s } @ 1$ for 10 hops still $8 9 . 7 \%$ . It also illustrates the ability to predict entities in a KB, as well as relations.
+
+We also compare these results to two much more complex architectures that perform end-to-end question answering in the same setting used here: VRN (Zhang et al., 2018), GRAFT-Net (Sun et al., 2018), and PullNet (Sun et al., 2019). All three systems build question-dependent subgraphs of the
+
+Table 3: Hits $@ 1$ on the KBQA datasets. Results for KV-Mem and VRN on MetaQA are from (Zhang et al., 2018); results for GRAFT-Net, PullNet and KV-Mem on WebQSP are from (Sun et al., 2018) and (Sun et al., 2019).   
+
+<table><tr><td></td><td>ReifKB (ours)</td><td>ReifKB +mask</td><td>KV-Mem (baseline)</td><td>VRN</td><td>GRAFT- Net</td><td>PullNet</td><td colspan="2">non-differentiable components of architectures</td></tr><tr><td>WebQSP MetaQA</td><td>52.7</td><td></td><td>46.7</td><td></td><td>67.8</td><td>68.1</td><td>KV-Mem</td><td>initial memory retrieval</td></tr><tr><td>1-hop</td><td>96.2</td><td></td><td>95.8</td><td>97.5</td><td>97.0</td><td>97.0</td><td></td><td></td></tr><tr><td>2-hop</td><td>81.1</td><td>95.4</td><td>25.1</td><td>89.9</td><td>94.8</td><td>99.9</td><td>VRN</td><td>question-specific</td></tr><tr><td>3-hop</td><td>72.3</td><td>79.7</td><td>10.1</td><td>62.5</td><td>77.2</td><td>91.4</td><td>GRAFTNet</td><td>subgraph retrieval</td></tr><tr><td>Grid 5-hop</td><td>98.4</td><td></td><td></td><td></td><td></td><td></td><td>PullNet</td><td>all iterative retrievals</td></tr><tr><td>10-hop</td><td>89.7</td><td></td><td></td><td></td><td></td><td>1</td><td>ReifKB(ours)</td><td>none</td></tr></table>
+
+KB, and then use graph CNN-like methods (Kipf & Welling, 2016) to “reason” with these graphs. Although not superior, ReifKB model is competitive with these approaches, especially on the most difficult 3-hop setting.
+
+A small extension to this model is to mask the seed entities out of the answers (see Appendix E). This model (given as ReifKB $^ +$ mask) has better performance than GRAFT-Net on 2-hop and 3-hop questions.
+
+For KB completion, we evaluated the model on the NELL-995 dataset (Xiong et al., 2017) which is paired with a KB with $1 5 4 \mathrm { k }$ facts, $7 5 \mathrm { k }$ entities, and 200 relations. On the left of Table 4 we compare our model with three popular embedding approaches (results are from Das et al. (2017)). The reified KB model outperforms DistMult (Yang et al., 2014), is slightly worse than ConvE (Dettmers et al., 2018), and is comparable to ComplEx (Trouillon et al., 2017).
+
+The competitive performance of the ReifKB model is perhaps surprising, since it has many fewer parameters than the baseline models—only one float and two integers per KB triple, plus a small number of parameters to define the $f _ { i } ^ { t }$ functions for each relation. The ability to use fewer parameters is directly related to the fact that our model directly uses inference on the existing symbolic $K B$ in its model, rather than having to learn embeddings that approximate this inference. Or course, since the KB is incomplete, some learning is still required, but learning is quite different: the system learns logical inference chains in the incomplete KB that approximate a target relation. In this setting for KBC, the ability to perform logical inference “out of the box” appears to be very advantageous.
+
+Another relative disadvantage of KB embedding methods is that KB embeddings are generally transductive—they only make predictions for entities seen in training. As a non-transductive baseline, we also compared to the MINERVA model, which uses reinforcement learning (RL) methods to learn how to traverse a KB to find a desired answer. Although RL methods are less suitable as “neural modules”, MINERVA is arguably a plausible competitor to end-to-end learning with a reified KB.
+
+MINERVA slightly outperforms our simple KB completion model on the NELL-995 task. However, unlike our model, MINERVA is trained to find a single answer, rather than trained to infer a set of answers. To explore this difference, we compared to MINERVA on the grid task under two conditions: (1) the KB relations are the grid directions north, south, east and west, so the output of the target chain is always a single grid location, and (2) the KB relations also include a “vertical move” (north or south) and a “horizontal move” (east or west), so the result of the target chain can be a set of locations. As expected MINERVA’s performance drops dramatically in the second case, from $9 9 . 3 \%$
+
+Table 4: Left: Hits $@ 1$ and Hits $@ 1 0$ for KB completion on NELL 995. Starred KB completion methods are transductive, and do not generalize to entities not seen in training. Right: Comparison to MINERVA on several tasks for Hits $@ 1$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="2">NELL-995</td><td rowspan="2">NELL-995</td><td rowspan="2">ReifKB (Ours) 64.1</td><td rowspan="2">MINERVA 66.3</td></tr><tr><td>H@1</td><td>H@10</td></tr><tr><td>ReifKB (Ours)</td><td>64.1</td><td>82.4</td><td>Grid with seed entity</td><td></td><td></td></tr><tr><td>DistMult*</td><td>61.0</td><td>79.5</td><td>10-hop NSEW</td><td>98.9</td><td>99.3</td></tr><tr><td>ComplEx*</td><td>61.2</td><td>82.7</td><td>10-hop NSEW-VH</td><td>73.6</td><td>34.4</td></tr><tr><td>ConvE*</td><td>67.2</td><td>86.4</td><td>MetaQA 3-hop</td><td>72.3</td><td>41.7</td></tr></table>
+
+Table 5: Left, time to run 10K examples for KBs of different size. Right, time for 10k examples vs Hits $@ 1$ performance for ReifKB compared to three baselines on MetaQA-3hop questions.   
+
+<table><tr><td colspan="4"></td><td colspan="4">●Reif KB● KV-mem● GRAFT-Net●PulINet</td></tr><tr><td></td><td>NELL-995</td><td>MetaQA-3hop</td><td>WebQuestionsSP</td><td>100</td><td></td><td></td><td></td></tr><tr><td>#Facts</td><td>154,213</td><td>196,453</td><td>43,724,175</td><td>75</td><td></td><td></td><td></td></tr><tr><td>#Entities</td><td>75,492</td><td>43,230</td><td>12,942,798</td><td>50</td><td rowspan="3"></td><td rowspan="3"></td><td rowspan="3"></td></tr><tr><td>#Relations</td><td>200</td><td>9</td><td>616</td><td>25</td></tr><tr><td>Time (seconds)</td><td>44.3</td><td>72.6</td><td>1820</td><td>0 250 500</td></tr></table>
+
+Hits $@ 1$ to $34 . 4 \%$ , while our model’s performance is more robust. MetaQA answers can also be sets, so we also modified MetaQA so that MINERVA could be used (by making the non-entity part of the sentence the “relation” input and the seed entity the “start node” input) and noted a similarly poor performance for MINERVA. These results are shown on the right of Table 4.
+
+In Tables 5 we compare the training time of our model with minibatch size of 10 on NELL-995, MetaQA, and WebQuestionsSP. With over 40 million facts and nearly 13 million entities from Freebase, it takes less than 10 minutes to run one epoch over WebQuestionsSP (with 3097 training examples) on four P100 GPUs. In the accompanying plot, we also summarize the tradeoffs between accuracy and training time for our model and three baselines on the MetaQA 3-hop task. (Here ideal performance is toward the upper left of the plot). The state-of-the-art PullNet Sun et al. (2019) system, which uses a learned method to incrementally retrieve from the KB, is about 15 times slower than the reified KB system. GRAFT-Net is only slightly less accurate, but also only slightly faster: recall that GRAFT-Net uses a heuristically selected subset (of up to 500 triples) from the KB for each query, while our system uses the full KB. Here the full KB is about 400 times as large as the question-specific subset used by GRAFT-Net. A key-value memory baseline including the full KB is nearly three times as slow as our system, while also performing quite poorly.
+
+# 4 RELATED WORK
+
+The relation-set following operation using reified KBs is implemented in an open-source package called NQL, for neural query language. NQL implements a broader range of operations for manipulating KBs, which are described in a companion paper (Cohen et al., 2019). This paper focuses on implementation and evaluation of the relation-set following operation with different KB representations, issues not covered in the companion paper.
+
+TensorLog (Cohen et al., 2017), a probabilistic logic which also can be compiled to Tensorflow, and hence is another differentiable approach to neuralizing a KB. TensorLog is also based on sparse matrices, but does not support relation sets, making it unnatural to express the models shown in this paper, and does not use the more efficient reified KB representation. The differentiable theorem prover (DTP) is another differentiable logic (Rocktäschel & Riedel, 2017), but DPT appears to be much less scalable: it has not been applied to KBs larger than a few thousand triples. The Neural ILP system (Yang et al., 2017) uses approaches related to late mixing together with an LSTM controller to perform KB completion and some simple QA tasks, but it is a monolithic architecture focused on rule-learning, while in contrast we propose a re-usable neural component, which can be used in as a component in many different architectures, and a scalable implementation of this. It has also been reported that neural ILP does not scale to the size of the NELL995 task (Das et al., 2017).
+
+The goals of this paper are related to KB embedding methods, but distinct. In KB embedding, models are generally fully differentiable, but it is not considered necessary (or even desirable) to accurately match the behavior of inference in the original KB. Being able to construct a learned approximation of a symbolic KB is undeniably useful in some contexts, but embedded KBs also have many disadvantages. In particular, they are much larger than a reified KB, with many more learned parameters—typically a long dense vector for every KB entity. Embedded models are typically evaluated by their ability to score a single triple accurately, and many models are not capable of executing multi-step KB inferences efficiently; further, models that do allow multi-step inference are known to produce cascaded errors on long reasoning chains (Guu et al., 2015; Hamilton et al., 2018). In contrast we focus on accurate models of reasoning in a symbolic KB, which requires consideration of novel scalability issues associated with sparse matrice representations.
+
+Mathematically, our definition of relation-set following is much like the bilinear model for path following from Guu et al. (2015); however, we generalize this to path queries that include weighted sets of relations, allowing the relations in paths to be learned. Similar differences apply to the work of Hamilton et al. (2018), which extends the work of Guu et al. (2015) to include intersection operations. The vector representation used here for weighted sets in a reified KB makes intersection trivial to implement, as intersection corresponds to Hadamard product. Conveniently set union also corresponds to vector sum, and the complement of $X$ is ${ \bf 1 } - { \bf x }$ , which is perhaps why only a single additional neural operation is needed to support the KB reasoning tasks needed for the five benchmark tasks considered here.
+
+Neural architectures like memory networks (Weston et al., 2014), or other architectures that use attention over some data structure approximating assertions (Andreas et al., 2016; Gupta & Lewis, 2018) can be used to build soft versions of relation-set following: however, they also do not scale well to large KBs, so they are typically used either with a non-differentiable ad hoc retrieval mechanism, or else in cases where a small amount of information is relevant to a question (Weston et al., 2015; Zhong et al., 2017). Similarly graph CNNs (Kipf & Welling, 2016) also can be used for reasoning, and often do use sparse matrix multiplication, but again existing implementations have not been scaled to tens of millions of triples/edges or millions of entities/graph nodes. Additionally, while graph CNNs have been used for reasoning tasks, the formal connection between them and logical reasoning remains unclear, whereas there is a precise connection between relation-set following and inference.
+
+Reinforcement learning (RL) methods have been used to learn mappings from natural-language questions to non-differentiable logical representations (Liang et al., 2016; 2018) and have also been applied to KB completion tasks (Das et al., 2017; Xiong et al., 2017). Above we compared experimentally to MINERVA, one such method; however, the gradient-based approaches enabled by our methods are generally preferred as being easier to implement and tune on new problems, and easier to combine in a modular way with other architectural elements.
+
+# 5 CONCLUSIONS
+
+We introduced here a novel way of representing a symbolic knowledge base (KB) called a sparsematrix reified KB. This representation enables neural modules that are fully differentiable, faithful to the original semantics of the KB, expressive enough to model multi-hop inferences, and scalable enough to use with realistically large KBs. In a reified KB, all KB relations are represented with three sparse matrices, which can be distributed across multiple GPUs, and symbolic reasoning on realistic KBs with many relations is much faster than with naive implementations—more than four orders of magnitude faster on synthetic-data experiments compared to naive sparse-matrix implementations.
+
+This new architectural component leads to radically simpler architectures for neural semantic parsing from denotations and KB completion—in particular, they make it possible to learn neural KBQA models in a completely end-to-end way, mapping from text to KB entity sets, for KBs with tens of millions of triples and entities and hundreds of relations.
+
+# ACKNOWLEDGMENTS
+
+The authors are greatful to comments and suggestions from Fernando Peireira, Bhuwan Dhingra, and many other colleagues on earlier versions of this work.
+
+# REFERENCES
+
+Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In 12th {USENIX} Symposium on Operating Systems Design and Implementation ({OSDI} 16), pp. 265–283, 2016.
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 39–48, 2016.
+
+Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. Semantic parsing on freebase from question-answer pairs. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pp. 1533–1544, 2013.
+
+Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. Freebase: a collaboratively created graph database for structuring human knowledge. In Proceedings of the 2008 ACM SIGMOD international conference on Management of data, pp. 1247–1250. AcM, 2008.
+
+Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In Advances in neural information processing systems, pp. 2787–2795, 2013.
+
+William W Cohen, Fan Yang, and Kathryn Rivard Mazaitis. Tensorlog: Deep learning meets probabilistic DBs. arXiv preprint arXiv:1707.05390, 2017.
+
+William W. Cohen, Matthew Siegler, and R. Alex Hofer. Neural query language: A knowledge base query language for Tensorflow. CoRR, abs/1905.06209, 2019. URL http://arxiv.org/ abs/1905.06209.
+
+Rajarshi Das, Shehzaad Dhuliawala, Manzil Zaheer, Luke Vilnis, Ishan Durugkar, Akshay Krishnamurthy, Alex Smola, and Andrew McCallum. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. arXiv preprint arXiv:1711.05851, 2017.
+
+Pradeep Dasigi, Matt Gardner, Shikhar Murty, Luke Zettlemoyer, and Eduard Hovy. Iterative search for weakly supervised semantic parsing. 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), pp. 2669–2680, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1273. URL https: //www.aclweb.org/anthology/N19-1273.
+
+Luc De Raedt, Angelika Kimmig, and Hannu Toivonen. Problog: A probabilistic Prolog and its application in link discovery. In IJCAI, volume 7, pp. 2462–2467. Hyderabad, 2007.
+
+Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. Convolutional 2d knowledge graph embeddings. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Catherine Finegan-Dollak, Jonathan K Kummerfeld, Li Zhang, Karthik Ramanathan, Sesh Sadasivam, Rui Zhang, and Dragomir Radev. Improving text-to-SQL evaluation methodology. arXiv preprint arXiv:1806.09029, 2018.
+
+Nitish Gupta and Mike Lewis. Neural compositional denotational semantics for question answering. CoRR, abs/1808.09942, 2018. URL http://arxiv.org/abs/1808.09942.
+
+Kelvin Guu, John Miller, and Percy Liang. Traversing knowledge graphs in vector space. arXiv preprint arXiv:1506.01094, 2015.
+
+Will Hamilton, Payal Bajaj, Marinka Zitnik, Dan Jurafsky, and Jure Leskovec. Embedding logical queries on knowledge graphs. In Advances in Neural Information Processing Systems, pp. 2026– 2037, 2018.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Chen Liang, Jonathan Berant, Quoc Le, Kenneth D Forbus, and Ni Lao. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. arXiv preprint arXiv:1611.00020, 2016.
+
+Chen Liang, Mohammad Norouzi, Jonathan Berant, Quoc V Le, and Ni Lao. Memory augmented policy optimization for program synthesis and semantic parsing. In Advances in Neural Information Processing Systems, pp. 9994–10006, 2018.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013.
+
+Alexander H. Miller, Adam Fisch, Jesse Dodge, Amir-Hossein Karimi, Antoine Bordes, and Jason Weston. Key-value memory networks for directly reading documents. CoRR, abs/1606.03126, 2016. URL http://arxiv.org/abs/1606.03126.
+
+Dipendra Misra, Ming-Wei Chang, Xiaodong He, and Wen-tau Yih. Policy shaping and generalized update equations for semantic parsing from denotations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 2442–2452, 2018.
+
+Panupong Pasupat and Percy Liang. Inferring logical forms from denotations. arXiv preprint arXiv:1606.06900, 2016.
+
+Tim Rocktäschel and Sebastian Riedel. End-to-end differentiable proving. In Advances in Neural Information Processing Systems, pp. 3788–3800, 2017.
+
+Peter Shaw, Philip Massey, Angelica Chen, Francesco Piccinno, and Yasemin Altun. Generating logical forms from graph representations of text and entities. arXiv preprint arXiv:1905.08407, 2019.
+
+Noam Shazeer, Youlong Cheng, Niki Parmar, Dustin Tran, Ashish Vaswani, Penporn Koanantakool, Peter Hawkins, HyoukJoong Lee, Mingsheng Hong, Cliff Young, Ryan Sepassi, and Blake A. Hechtman. Mesh-tensorflow: Deep learning for supercomputers. CoRR, abs/1811.02084, 2018. URL http://arxiv.org/abs/1811.02084.
+
+Haitian Sun, Bhuwan Dhingra, Manzil Zaheer, Kathryn Mazaitis, Ruslan Salakhutdinov, and William W Cohen. Open domain question answering using early fusion of knowledge bases and text. EMNLP, 2018.
+
+Haitian Sun, Tania Bedrax-Weiss, and William W Cohen. Pullnet: Open domain question answering with iterative retrieval on knowledge bases and text. arXiv preprint arXiv:1904.09537, 2019.
+
+Théo Trouillon, Christopher R Dance, Éric Gaussier, Johannes Welbl, Sebastian Riedel, and Guillaume Bouchard. Knowledge graph completion via complex tensor factorization. The Journal of Machine Learning Research, 18(1):4735–4772, 2017.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, Alexander M Rush, Bart van Merriënboer, Armand Joulin, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698, 2015.
+
+Wenhan Xiong, Thien Hoang, and William Yang Wang. Deeppath: A reinforcement learning method for knowledge graph reasoning. arXiv preprint arXiv:1707.06690, 2017.
+
+Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Embedding entities and relations for learning and inference in knowledge bases. arXiv preprint arXiv:1412.6575, 2014.
+
+Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base reasoning. In Advances in Neural Information Processing Systems, pp. 2319–2328, 2017.
+
+Wen-tau Yih, Ming-Wei Chang, Xiaodong He, and Jianfeng Gao. Semantic parsing via staged query graph generation: Question answering with knowledge base. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), volume 1, pp. 1321–1331, 2015.
+
+Wen-tau Yih, Matthew Richardson, Chris Meek, Ming-Wei Chang, and Jina Suh. The value of semantic parse labeling for knowledge base question answering. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), volume 2, pp. 201–206, 2016.
+
+Yuyu Zhang, Hanjun Dai, Zornitsa Kozareva, Alexander J Smola, and Le Song. Variational reasoning for question answering with knowledge graph. In AAAI, 2018.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. arXiv preprint arXiv:1709.00103, 2017.
+
+# A ADDITIONAL BACKGROUND AND EXTENSIONS
+
+KBs, entities, and relations, and types. In the more general case, a KB consists of entities, relations, and types. Again use $x$ to denote an entity and $r$ to denote a relation. We also assume each entity $x$ has a type, written $t y p e ( x )$ , and let $N _ { \tau }$ denote the number of entities of type $\tau$ . Each entity $x$ in type $\tau$ has a unique index $i n d e x _ { \tau } ( x )$ , which is an integer between 1 and $N _ { \tau }$ . We write $x _ { \tau , i }$ for the entity that has index $i$ in type $\tau$ , or $x _ { i }$ if the type is clear from context.
+
+Every relation $r$ has a subject type $\tau _ { s u b j }$ and an object type $\tau _ { o b j }$ , which constrain the types of $x$ and $x ^ { \prime }$ for any pair $( x , x ^ { \prime } ) \in r$ . Hence $r$ can be encoded as a subset of $\{ 1 , \dots , N _ { \tau _ { s u b j } } \} \times \{ 1 , \dots , N _ { \tau _ { o b j } } \}$ Relations with the same subject and object types are called type-compatible.
+
+Our differentiable operations are based on typed weighted sets, where again each element $x$ of weighted set $X$ is associated with a non-negative real number, written $\omega \| x \in X ]$ , and we define $\omega \bar { \left\| { \boldsymbol { x } } \in { \boldsymbol { X } } \right\| } \equiv 0$ for all $x \not \in X$ . A set $X$ has a type $t y p e ( X ) = \tau$ , and all members of $X$ must be entities of type $\tau$ .
+
+We also assume every relation $r$ in a KB is associated with an entity $x _ { r }$ , and hence, an index and a type. Sets of relations $R$ are allowed only if all members are type-compatible. For example $R = \{ w r i t e r \_ o f , d i r e c t o r \_ o f \}$ might be a set of type-compatible relations.
+
+A weighted set $X$ of type $\tau$ can be encoded as an entity-set vector $\mathbf { x } \in \mathbb { R } ^ { N _ { \tau } }$ , where the $i$ -th component of $\mathbf { X }$ is the weight of the $i$ -th entity of that type in the set $X$ : e.g., $\mathbf { x } [ i n d e x _ { \tau } ( x ) ] = { \boldsymbol { \omega } } [ x \in X ]$ . We also use $t y p e ( \mathbf { x } )$ to denote the type $\tau$ of the set encoded by $\mathbf { X }$ .
+
+A relation $r$ with subject type $\tau _ { 1 }$ and object type $\tau _ { 2 }$ can be encoded as a relation matrix ${ \mathbf { M } } _ { r } \in { \mathbf { \Omega } }$ $\mathbb { R } ^ { N _ { \tau _ { 1 } } \times N _ { \tau _ { 2 } } }$ .
+
+Background on sparse matrices. A COO encoding consists of a $N _ { r } \times 2$ matrix $\mathbf { I n d } _ { r }$ containing pairs of entity indices, and a parallel vector $\mathbf { w } _ { r } \in \mathbb { R } ^ { \widetilde { N } _ { r } }$ containing the weights of the corresponding entity pairs. In this encoding, if $( i , j )$ is row $k$ of Ind, then $\mathbf { M } _ { r } [ i , j ] = \mathbf { w } _ { r } [ k ]$ , and if $( i , j )$ does not appear in $\mathbf { I n d } _ { r }$ , then $\mathbf { M } [ i , j ]$ is zero.
+
+Extension to soft KBs. In the paper, we assume the non-zero weights in a relation matrix ${ { \bf { M } } _ { r } }$ are all equal to 1.0. This can be relaxed: if assertions in a KB are associated with confidences, then this confidence can be stored in ${ { \bf { M } } _ { r } }$ . In this case, the reified KB must be extended to encode the weight for a triple: we find it convenient to redefine ${ { \bf { M } } _ { r e l } }$ to hold that weight. In particular if the weight for the the $\ell$ -th triple $r _ { k } ( x _ { i } , x _ { j } )$ is $w _ { \ell }$ , then we let
+
+$$
+\mathbf { M } _ { r e l } [ \ell , m ] \equiv { \left\{ \begin{array} { l l } { w _ { \ell } \ \mathrm { i f } \ m = k _ { \ell } } \\ { 0 \ \mathrm { e l s e } } \end{array} \right. }
+$$
+
+# B PROOF OF CLAIM 1
+
+Claim 1 The support of follow $\scriptstyle ( \mathbf { x } , \pmb { r } )$ is exactly the set of R-neighbors( $X )$ .
+
+To better understand this claim, let $\mathbf { z } = f o l l o w ( \mathbf { x } , \mathbf { r } )$ . The claim states $\mathbf { z }$ can approximate the $R$ neighborhood of any hard sets $R , X$ by setting to zero the appropriate components of $\mathbf { X }$ and $\mathbf { r }$ . It is also clear that $\mathbf { z } [ j ]$ decreases when one decreases the weights in r of the relations that link $x _ { j }$ to entities in $X$ , and likewise, $\mathbf { z } [ j ]$ decreases if one decreases the weights of the entities in $X$ that are linked to $x _ { j }$ via relations in $R$ , so there is a smooth, differentiable path to reach this approximation.
+
+More formally, consider first a matrix ${ { \bf { M } } _ { r } }$ encoding a single binary relation $r$ , and consider the vector $\mathbf { x } ^ { \prime } = \mathbf { x } \mathbf { M } _ { r }$ . As weighted sets, $X$ and $r$ have non-negative entries, so clearly for all $i$ ,
+
+$$
+\mathbf { x } ^ { \prime } [ j ] \neq 0 \mathrm { ~ i f f ~ } \exists j : \mathbf { M } _ { r } [ i , j ] \neq 0 \land \mathbf { x } [ i ] \neq 0
+$$
+
+and so if $\mathbf { r }$ is a one-hot vector for the set $\{ r \}$ , then the support of $f o l l o w ( \mathbf { x } , \mathbf { r } )$ is exactly the set $r$ -neighbors $( X )$ . Finally note that the mixture $\mathbf { M } _ { R }$ has the property that ${ \bf M } _ { R } [ i ( e _ { 1 } ) , i ( e _ { 2 } ) ] > 0$ exactly when $e _ { 1 }$ is related to $e _ { 2 }$ by some relation $r \in R$ .
+
+The major problem with naive mixing is that, in the absence of general sparse tensor contractions, it is difficult to adapt to mini-batches—i.e., a setting in which $\mathbf { X }$ and $\mathbf { r }$ are replaced with matrices $\mathbf { X }$ and $\mathbf { R }$ with minibatch size $b$ . An alternative strategy is late mixing, which mixes the output of many single-relation following steps, rather than mixing the KB itself:
+
+$$
+f o l l o w ( { \mathbf { X } } , { \mathbf { R } } ) = \sum _ { k = 1 } ^ { N _ { R } } ( { \mathbf { R } } [ : , k ] \cdot { \mathbf { X } } { \mathbf { M } } _ { k } )
+$$
+
+Here $\mathbf { R } [ : , k ]$ , the $k$ -th column of $\mathbf { R }$ , is “broadcast” to element of the matrix $\mathbf { X M } _ { k }$ . As noted in the body of the text, while there are $N _ { R }$ matrices $\mathbf { X M } _ { k }$ , each of size $O ( b N _ { E } )$ , they need not all be stored at once, so the space complexity becomes $O ( b N _ { E } + b N _ { R } + N _ { T } )$ ; however we must now sum up $N _ { R }$ dense matrices.
+
+The implementation of relation-set following for the reified KB can be straightforwardedly extended to a minibatch:
+
+$$
+f o l l o w ( \mathbf { X } , \mathbf { R } ) = ( \mathbf { X } \mathbf { M } _ { s u b j } ^ { T } \odot \mathbf { R } \mathbf { M } _ { r e l } ^ { T } ) \mathbf { M } _ { o b j }
+$$
+
+# D DISTRIBUTED MATRIX MULTIPLICATION
+
+Matrix multiplication $\mathbf { x M }$ was distributed as follows: $\mathbf { X }$ can be split into a “horizontal stacking” of $m$ submatrices, which we write as $\left[ \mathbf { x } _ { 1 } ; \ldots ; \mathbf { x } _ { m } \right]$ , and $\mathbf { M }$ can be similarly partitioned into $m ^ { 2 }$ submatrices. We then have the result that
+
+$$
+\mathbf { x M } = [ \mathbf { x } _ { 1 } ; \mathbf { x } _ { 2 } ; \ldots ; \mathbf { x } _ { m } ] \left[ { \begin{array} { c c c c } { \mathbf { M } _ { 1 , 1 } } & { \mathbf { M } _ { 1 , 2 } } & { \ldots } & { \mathbf { M } _ { 1 , m } } \\ { \vdots } & { \vdots } & { } & { \vdots } \\ { \mathbf { M } _ { m , 1 } } & { \mathbf { M } _ { m , 2 } } & { \ldots } & { \mathbf { M } _ { m , m } } \end{array} } \right] = \left[ ( \sum _ { i = 1 } ^ { m } \mathbf { x } _ { 1 } \mathbf { M } _ { i , 1 } ) ; \ldots ; ( \sum _ { i = 1 } ^ { m } \mathbf { x } _ { m } \mathbf { M } _ { i , m } ) \right]
+$$
+
+This can be computed without storing either $\mathbf { X }$ or $\mathbf { M }$ on a single machine, and mathematically applies to both dense and sparse matrices. In our experiments we distibuted the matrices that define a reified KB “horizontally”, so that different triple ids $\ell$ are stored on different GPUs.
+
+Specifically, we shard the “triple index” dimension $N _ { T }$ of matrices $\mathbf { M } _ { s u b j }$ , ${ { \bf { M } } _ { r e l } }$ and $\mathbf { M } _ { o b j }$ in Eq. 4 to perform a distributed relation-set following on the reified KB. Let $\mathbf { M } _ { s u b j , i }$ be the $\overrightarrow { \imath } ^ { \prime }$ th shard of matrix $\mathbf { M } _ { s u b j }$ , and thus $\mathbf { M } _ { s u b j } = [ \mathbf { M } _ { s u b j , 1 } ^ { T } ; . . . ; \mathbf { M } _ { s u b j , m } ^ { T } ] _ { . } ^ { T } \in \mathbb { R } ^ { N _ { T } \times N _ { E } }$ . $\mathbf { M } _ { o b j }$ and ${ { \bf { M } } _ { r e l } }$ are represented in the similar way. A distributed relation-set following is computed as a combination of relation-set following results on all shards of the KB.
+
+$$
+\begin{array} { l } { f o l l o w ( \mathbf { x } , \mathbf { r } ) = ( \mathbf { x } \mathbf { M } _ { s u b j } ^ { T } \odot \mathbf { r } \mathbf { M } _ { r e l } ^ { T } ) \mathbf { M } _ { o b j } } \\ { \quad \quad = \left( [ \mathbf { x } \mathbf { M } _ { s u b j , 1 } ^ { T } ; \dots ; \mathbf { x } \mathbf { M } _ { s u b j , m } ^ { T } ] \odot [ \mathbf { r } \mathbf { M } _ { r e l , 1 } ^ { T } ; \dots ; \mathbf { r } \mathbf { M } _ { r e l , m } ^ { T } ] \right) \left[ \begin{array} { c } { \mathbf { M } _ { o b j , 1 } } \\ { \vdots } \\ { \mathbf { M } _ { o b j , m } } \end{array} \right] } \\ { \quad \quad = \displaystyle \sum _ { i = 1 } ^ { m } ( \mathbf { x } \mathbf { M } _ { s u b j , i } ^ { T } \odot \mathbf { r } \mathbf { M } _ { r e l , i } ^ { T } ) \mathbf { M } _ { o b j , i } } \end{array}
+$$
+
+This method can be easily extended to a mini-batch of examples $\mathbf { X }$ .
+
+# E EXPERIMENTAL DETAILS
+
+Reproducing experiments. To reproduce these experiments, first download and install the Google language package5. Many of the experiments in this paper can be reproduced using scripts stored in the some subdirectory of the source directory language/nql/demos: for example, the scalability experiments of Figure 1 can be performed using scripts in language/nql/demos/gridworld_scaling/.
+
+Grid experiments. In the grid experiments, the entity vector $\mathbf { X }$ is a randomly-chosen singleton set, and the relation vector r weights relations roughly uniformly—more specifically, each relation has weight $1 { + } \epsilon$ where $\epsilon$ is a drawn uniformly at random between 0 and 0.001.6 We vary the number of relations by inventing $m$ new relation names and assigning existing grid edges to each new relation. These experiments were conducted on a Titan $\mathrm { X p }$ GPU with 12Gb of memory.
+
+For key-value networks, the key is the concatenation of a relation and a subject entity, and the value is the object entity. We considered only the run-time for queries on an untrained randomly-initialized network (since run-time performance on a trained network would be the same); however, it should be noted that considerable time that might be needed to train the key-value memory to approximate the KB. (In fact, it is not obvious under what conditions a KB can be approximated well by the key-value memory.)
+
+We do not show results on the grid task for smaller minibatch sizes, but both reified and late mixing are about $4 0 \mathrm { x }$ slower with $b = 1$ than with $b = 1 2 8$ .
+
+WebQuestionsSP experiments. For efficiency, on this problem we exploit the type structure of the problem (see Appendix A). Our model uses two types of nodes, CVT and entity nodes. The model also uses three types of relations: relations mapping entities to entities, relations mapping entities to CVT nodes; and relations mapping CVT nodes to entity nodes.
+
+MetaQA experiments. An example of a 2-hop question in MetaQA could be “Who co-starred with Robert Downey Jr. in their movies?”, and the answer would be a set of actor entities, e.g., “Chris Hemsworth”, “Thomas Stanley”, etc. Triples in the knowledge base are represented as (subject, relation, object) triples, e.g., (“Robert Downey Jr.”, “act_in”, “Avengers: Endgame”), (“Avengers: Endgame”, “stars”, “Thomas Stanley”), etc. The quoted strings here all indicate KB entities.
+
+We also observed that in the MetaQA 2-hop and 3-hop questions, the questions often exclude the seed entities (e.g., “other movies with the same director as Pulp Fiction”). This can be modeled by masking out seed entities from the predictions after the second hop (ReifKB $^ +$ mask in the table).
+
+Timing on MetaQA and other natural problems. The raw data for the bubble plot of Table 5 is below.   
+
+<table><tr><td>Time (seconds)</td><td>Accuracy (hits@1)</td><td>Method</td></tr><tr><td>72.6</td><td>79.7</td><td>ReifKB</td></tr><tr><td>189.8</td><td>10.1</td><td>KV-mem</td></tr><tr><td>28.9</td><td>77.2</td><td>GRAFT-Net</td></tr><tr><td>1131.0</td><td>91.4</td><td>PullNet</td></tr></table>
+
+Discussion of the KB completion model. The KB completion model is
+
+$$
+t = 1 , \dots , T \colon \ \mathbf { r } _ { i } ^ { t } = f _ { i } ^ { t } ( q ) ; \ \mathbf { x } _ { i } ^ { t } = f o l l o w ( \mathbf { x } _ { i } ^ { t - 1 } , \mathbf { r } _ { i } ^ { t } ) + \mathbf { x } _ { i } ^ { t - 1 }
+$$
+
+It may not be immediately obvious why we used
+
+$$
+\mathbf { x } _ { i } ^ { t } = f o l l o w ( \mathbf { x } _ { i } ^ { t - 1 } , \mathbf { r } _ { i } ^ { t } ) + \mathbf { x } _ { i } ^ { t - 1 }
+$$
+
+instead of the simpler
+
+$$
+\mathbf { x } _ { i } ^ { t } = f o l l o w ( \mathbf { x } _ { i } ^ { t - 1 } , \mathbf { r } _ { i } ^ { t } )
+$$
+
+In the main text, we say that this “gives the model access to outputs of all chains of length less than $t ^ { \ast }$ This statement is probably easiest to understand by considering a concete example. Let us simplify notation slightly by dropping the subscripts and writing follow $( \mathbf { x } _ { i } ^ { t - 1 } , \mathbf { r } _ { i } ^ { t } )$ as $f ^ { t } ( \mathbf { \bar { x } } ^ { t - 1 } )$ . Now expand the definition of $\mathbf { x } ^ { t }$ for a few small values of $t$ , using the linearity of the definition of relation-set
+
+following where appropriate to simplify:
+
+$$
+{ \begin{array} { r c l } { \mathbf { x } ^ { 1 } } & { = } & { f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } } \\ { \mathbf { x } ^ { 2 } } & { = } & { f ^ { 2 } ( \mathbf { x } ^ { 1 } ) + \mathbf { x } ^ { 1 } } \\ & { = } & { f ^ { 2 } \left( \left( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } \right) + \left( \left( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } \right) \right. \right. } \\ & { = } & { \left. f ^ { 2 } ( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) ) + f ^ { 2 } ( \mathbf { x } ^ { 0 } ) + f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } \right. } \\ { \mathbf { x } ^ { 3 } } & { = } & { f ^ { 3 } ( \mathbf { x } ^ { 2 } ) + \mathbf { x } ^ { 2 } } \\ & { = } & { f ^ { 3 } \left( \left( f ^ { 2 } ( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) \right) + f ^ { 2 } ( \mathbf { x } ^ { 0 } ) + f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } \right) + f ^ { 2 } ( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) ) + f ^ { 2 } ( \mathbf { x } ^ { 0 } ) + f ^ { 1 } ( \mathbf { x } ^ { 0 } ) + \mathbf { x } ^ { 0 } } \\ & { = } & { f ^ { 3 } { \big ( } f ^ { 2 } ( f ^ { 1 } ( \mathbf { x } ^ { 0 } ) { \big ) \big ) } + f ^ { 3 } { \big ( } f ^ { 2 } ( \mathbf { x } ^ { 0 } ) { \big ) } + f ^ { 3 } { \big ( } f ^ { 1 } ( \mathbf { x } ^ { 0 } ) { \big ) } + f ^ { 2 } { \big ( } f ^ { 1 } ( \mathbf { x } ^ { 0 } ) { \big ) } + f ^ { 2 } ( \mathbf { x } ^ { 0 } ) + f ^ { 2 } ( \mathbf { x } ^ { 0 } ) + f ^ { 1 } ( \mathbf { x } ^ { 0 } ) } \end{array} }
+$$
+
+A pattern is now clear: with this recursive definition $\mathbf { x } ^ { t }$ expands to a mixture of many paths, each of which applies a different subset of $f ^ { 1 }$ , . . . , $f ^ { t }$ to the initial input $\mathbf { X }$ . Since the weights of the mixture can to a large extent be controlled by varying the norm of the relation vectors $\mathbf { r } ^ { 1 } , \ldots . . . ^ { t }$ , this “kernel-like trick” increases the expressive power of the model without introducing new parameters. The final mixture of the $\mathbf { x } ^ { t }$ ’s seems to provide a bias towards accepting the output of shorter paths, which appears to be useful in practice.

parse/train/aExAsh1UHZo/aExAsh1UHZo.md

@@ -0,0 +1,422 @@
+# Gradient Starvation: A Learning Proclivity in Neural Networks
+
+Mohammad Pezeshki1,2 Sékou-Oumar Kaba1,3 Yoshua Bengio1,2 Aaron Courville1,2 Doina Precup1,3,4 Guillaume Lajoie1,2   
+1Mila 2Université de Montréal 3McGill University 4Google DeepMind   
+corresponding authors:{pezeshki, guillaume.lajoie}@mila.quebec
+
+# Abstract
+
+We identify and formalize a fundamental gradient descent phenomenon leading to a learning proclivity in over-parameterized neural networks. Gradient Starvation arises when cross-entropy loss is minimized by capturing only a subset of features relevant for the task, despite the presence of other predictive features that fail to be discovered. This work provides a theoretical explanation for the emergence of such feature imbalances in neural networks. Using tools from Dynamical Systems theory, we identify simple properties of learning dynamics during gradient descent that lead to this imbalance, and prove that such a situation can be expected given certain statistical structure in training data. Based on our proposed formalism, we develop guarantees for a novel but simple regularization method aimed at decoupling feature learning dynamics, improving accuracy and robustness in cases hindered by gradient starvation. We illustrate our findings with simple and realworld out-of-distribution (OOD) generalization experiments.
+
+# 1 Introduction
+
+In 1904, a horse named Hans attracted worldwide attention due to the belief that it was capable of doing arithmetic calculations [81]. Its trainer would ask Hans a question, and Hans would reply by tapping on the ground with its hoof. However, it was later revealed that the horse was only noticing subtle but distinctive signals in its trainer’s unconscious behavior, unbeknown to him, and not actually performing arithmetic. An analogous phenomenon has been noticed when training neural networks [e.g. 85, 109, 54, 39, 17, 14, 37, 51, 107, 76, 48, 19, 61, 77]. In many cases, state-of-the-art neural networks appear to focus on low-level superficial correlations, rather than more abstract and robustly informative features of interest [16, 88, 40, 68, 30].
+
+The rationale behind this phenomenon is well known by practitioners: given strongly-correlated and fast-to-learn features in training data, gradient descent is biased towards learning them first. However, the precise conditions leading to such learning dynamics, and how one might intervene to control this feature imbalance are not entirely understood. Recent work aims at identifying the reasons behind this phenomenon [97, 70, 22, 73, 51, 76, 100, 92, 83, 105, 42, 79, 4], while complementary work quantifies resulting shortcomings, including poor generalization to out-of-distribution (OOD) test data, reliance upon spurious correlations, and lack of robustness [30, 68, 77, 41, 63, 64, 9]. However most established work focuses on squared-error loss and its particularities, where results do not readily generalize to other objective forms. This is especially problematic since for several classification applications, cross-entropy is the loss function of choice, yielding very distinct learning dynamics. In this paper, we argue that Gradient Starvation, first coined in [26], is a leading cause for this feature imbalance in neural networks trained with cross-entropy, and propose a simple approach to mitigate it.
+
+![](images/9f945eaedc28dc850b70ed0f5a00c0d50de39ab2ea581ed85082d9da4e26613b.jpg)  
+Figure 1: Diagram illustrating the effect of gradient starvation in a simple 2-D classification task. (a) Data is not linearly separable and the learned decision boundary is curved. (b) Data is linearly separable by a small margin $\Delta = \mathrm { 0 . 1 }$ ). This small margin allows the network to discriminate confidently only along the horizontal axis and ignore the vertical axis. (c) Data is linearly separable as in (b). However, with the proposed Spectral decoupling (SD), a curved decision boundary with a large margin is learned. (d) Diagram shows the evolution of two of the features (Eq. 4) of the dynamics in three cases shown as dotted, dashed and solid lines. Analysis: (dotted) vs (dashed): Linear separability of the data results in an increase in $z _ { 1 }$ and a decrease (starvation) of $z _ { 2 }$ . (dashed) vs (solid): SD suppresses $z _ { 1 }$ and hence allows $z _ { 2 }$ to grow. Decision boundaries are averaged over ten runs. More experiments with common regularization methods are provided in App. B.
+
+Here we summarize our contributions:
+
+We provide a theoretical framework to study the learning dynamics of linearized neural networks trained with cross-entropy loss in a dual space. Using perturbation analysis, we formalize Gradient Starvation (GS) in view of the coupling between the dynamics of orthogonal directions in the feature space (Thm. 2). We leverage our theory to introduce Spectral Decoupling (SD) (Eq. 17) and prove this simple regularizer helps to decouple learning dynamics, mitigating GS. We support our findings with extensive empirical results on a variety of classification and adversarial attack tasks. All code and experiment details available at GitHub repository.
+
+In the rest of the paper, we first present a simple example to outline the consequences of GS. We then present our theoretical results before outlining a number of numerical experiments. We close with a review of related work followed by a discussion.
+
+# 2 Gradient Starvation: A simple example
+
+Consider a 2-D classification task with a training set consisting of two classes, as shown in Figure 1. A two-layer ReLU network with 500 hidden units is trained with cross-entropy loss for two different arrangements of the training points. The difference between the two arrangements is that, in one setting, the data is not linearly separable, but a slight shift makes it linearly separable in the other setting. This small shift allows the network to achieve a negligible loss by only learning to discriminate along the horizontal axis, ignoring the other. This contrasts with the other case, where both features contribute to the learned classification boundary, which arguably matches the data structure better. We observe that training longer or using different regularizers, including weight decay [58], dropout [95], batch normalization [49], as well as changing the optimization algorithm to Adam [56] or changing the network architecture or the coordinate system, do not encourage the network to learn a curved decision boundary. (See App. B for more details.)
+
+We argue that this occurs because cross-entropy loss leads to gradients “starved” of information from vertical features. Simply put, when one feature is learned faster than the others, the gradient contribution of examples containing that feature is diminished (i.e., they are correctly processed based on that feature alone). This results in a lack of sufficient gradient signal, and hence prevents any remaining features from being learned. This simple mechanism has potential consequences, which we outline below.
+
+# 2.1 Consequences of Gradient Starvation
+
+Lack of robustness. In the example above, even in the right plot, the training loss is nearly zero, and the network is very confident in its predictions. However, the decision boundary is located very close to the data points. This could lead to adversarial vulnerability as well as lack of robustness when generalizing to out-of-distribution data.
+
+Excessive invariance. GS could also result in neural networks that are invariant to task-relevant changes in the input. In the example above, it is possible to obtain a data point with low probability under the data distribution, but that would still be classified with high confidence.
+
+Implicit regularization. One might argue that according to Occam’s razor, a simpler decision boundary should generalize better. In fact, if both training and test sets share the same dominant feature (in this example, the feature along the horizontal axis), GS naturally prevents the learning of less dominant features that could otherwise result in overfitting. Therefore, depending on our assumptions on the training and test distributions, GS could also act as an implicit regularizer. We provide further discussion on the implicit regularization aspect of GS in Section 5.
+
+# 3 Theoretical Results
+
+In this section, we study the learning dynamics of neural networks trained with cross-entropy loss. Particularly, we seek to decompose the learning dynamics along orthogonal directions in the feature space of neural networks, to provide a formal definition of GS, and to derive a simple regularization method to mitigate it. For analytical tractability, we make three key assumptions: (1) we study deep networks in the Neural Tangent Kernel (NTK) regime, (2) we treat a binary classification task, (3) we decompose the interaction between two features. In Section 4, we demonstrate our results hold beyond these simplifying assumptions, for a wide range of practical settings. All derivation details can be found in $\mathbf { S M C }$ .
+
+# 3.1 Problem Setup and Gradient Starvation Definition
+
+Let ${ \mathcal { D } } = \{ { \bf X } , { \bf y } \}$ denote a training set containing $n$ datapoints with $d$ dimensions, where, $\mathbf { X } =$ $[ \mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { n } ] \in \mathbb { R } ^ { n \times d }$ and their corresponding class label $\mathbf { y } \in \{ - 1 , + 1 \} ^ { n }$ . Also let $\hat { \mathbf { y } } ( \mathbf { X } ) : = f ^ { ( L ) } ( \mathbf { X } ) :$ $\mathbb { R } ^ { n \times d } \to \mathbb { R } ^ { n }$ represent the logits of an $\mathrm { L }$ -layer fully-connected neural network where each hidden layer $h ^ { ( l ) } ( x ) \in \mathbf { \bar { \mathbb { R } } } ^ { d _ { l } }$ is defined as follows,
+
+$$
+\begin{array} { r } { \left\{ \begin{array} { l l } { \boldsymbol { f } ^ { ( l ) } ( \mathbf { x } _ { i } ) = \mathbf { W } ^ { ( l ) } h ^ { ( l - 1 ) } ( \mathbf { x } _ { i } ) } \\ { h ^ { ( l ) } ( \mathbf { x } _ { i } ) = \sqrt { \frac { \gamma } { d _ { l } } } \boldsymbol { \xi } ( \boldsymbol { f } ^ { ( l ) } ( \mathbf { x } _ { i } ) ) } \end{array} \right. , l \in \{ 0 , 1 , . . . , L \} , } \end{array}
+$$
+
+in which $\mathbf { W } ^ { ( l ) } \in \mathbb { R } ^ { d _ { l } \times d _ { l - 1 } }$ is a weight matrix drawn from $\mathcal { N } ( 0 , \bf { I } )$ and $\gamma$ is a scaling factor to ensure that norm of each $\boldsymbol { h } ^ { ( l - 1 ) }$ is preserved at initialization (See [28] for a formal treatment). The function $\xi ( . )$ is also an element-wise non-linear activation function.
+
+Let $\pmb \theta = \mathrm { c o n c a t } \big ( \cup _ { l = 1 } ^ { L } \mathrm { v e c } ( \mathbf W ^ { ( l ) } ) \big ) \in \mathbb { R } ^ { m }$ be the concatenation of all vectorized weight matrices with $m$ as the total number of parameters. In the NTK regime [52], in the limit of infinite width, the output of the neural network can be approximated as a linear function of its parameters governed by the neural tangent random feature (NTRF) matrix [23],
+
+$$
+\Phi \left( \mathbf { X } , \theta \right) = \frac { \partial \hat { \mathbf { y } } \left( \mathbf { X } , \theta \right) } { \partial \theta } \in \mathbb { R } ^ { n \times m } .
+$$
+
+In the wide-width regime, the NTRF changes very little during training [62], and the output of the neural network can be approximated by a first order Taylor expansion around the initialization parameters $\pmb { \theta } _ { 0 }$ . Setting $\Phi _ { 0 } \equiv \Phi \left( \mathbf { X } , \pmb { \theta } _ { 0 } \right)$ and then, without loss of generality, centering parameters and the output coordinates to their value at the initialization ${ \bf \delta _ { \theta } }$ and $\hat { \mathbf { y } } _ { 0 , }$ ), we get
+
+$$
+\hat { \mathbf { y } } \left( \mathbf { X } , \pmb { \theta } \right) = \Phi _ { 0 } \pmb { \theta } .
+$$
+
+Dominant directions in the feature space as well as the parameter space are given by principal components of the NTRF matrix $\Phi _ { 0 }$ , which are the same as those of the NTK Gram matrix [106]. We therefore introduce the following definition.
+
+Definition 1 (Features and Responses). Consider the singular value decomposition (SVD) of the matrix $\mathbf { Y } \Phi _ { 0 } = \mathbf { U } \mathbf { S } \mathbf { V } ^ { T }$ , where $\mathbf { Y } = d i a g \left( \mathbf { y } \right)$ . The jth feature is given by $( \mathbf { \dot { V } } ^ { T } ) _ { j . }$ .. The strength of jth feature is represented by $s _ { j } = ( \mathbf { S } ) _ { j j }$ . Also, $( \mathbf { U } ) _ { \cdot j }$ contains the weights of this feature in all examples. A neural network’s response to a feature $j$ is given by $z _ { j }$ where,
+
+$$
+\mathbf { z } : = \mathbf { U } ^ { T } \mathbf { Y } \hat { \mathbf { y } } = \mathbf { S } \mathbf { V } ^ { T } \pmb { \theta } .
+$$
+
+In Eq. 4, the response to feature $j$ is the sum of the responses to every example in $( \mathbf { Y } \hat { \mathbf { y } } )$ multiplied by the weight of the feature in that example $( \mathbf { U } ^ { T } )$ . For example, if all elements of $( \mathbf { U } ) _ { \cdot j }$ are positive, it indicates a perfect correlation between this feature and class labels. We are now equipped to formally define GS.
+
+Definition 2 (Gradient Starvation). Recall the the model prescribed by Eq. 3. Let $z _ { j } ^ { \ast }$ denote the model’s response to feature $j$ at training optimum $\pmb { \theta } ^ { * 1 }$ . Feature $i$ starves the gradient for feature $j$ $i f d z _ { j } ^ { * } / d ( s _ { i } ^ { 2 } ) < 0$ .
+
+This definition of GS implies that an increase in the strength of feature $i$ has a detrimental effect on the learning of feature $j$ . We now derive conditions for which learning dynamics of system 3 suffer from GS.
+
+# 3.2 Training Dynamics
+
+We consider the widely used ridge-regularized cross-entropy loss function,
+
+$$
+\mathcal { L } \left( \pmb { \theta } \right) = \mathbf { 1 } \cdot \log \left[ 1 + \exp \left( - \mathbf { Y } \hat { \mathbf { y } } \right) \right] + \frac { \lambda } { 2 } \| \pmb { \theta } \| ^ { 2 } ,
+$$
+
+where 1 is a vector of size $n$ with all its elements equal to 1. This vector form simply represents a summation over all the elements of the vector it is multiplied to. $\lambda \in [ 0 , \infty )$ denotes the weight decay coefficient.
+
+Direct minimization of this loss function using the gradient descent obeys coupled dynamics and is difficult to treat directly [26]. To overcome this problem, we call on a variational approach that leverages the Legendre transformation of the loss function. This allows tractable dynamics that can directly incorporate rates of learning in different feature directions. Following [50], we note the following inequality,
+
+$$
+\begin{array} { r } { \log \left[ 1 + \exp \left( - \mathbf { Y } \hat { \mathbf { y } } \right) \right] \geq H ( \alpha ) - \alpha \odot \mathbf { Y } \hat { \mathbf { y } } , } \end{array}
+$$
+
+where $H ( \pmb { \alpha } ) = - \left[ \pmb { \alpha } \log \pmb { \alpha } + ( 1 - \pmb { \alpha } ) \log \left( 1 - \pmb { \alpha } \right) \right]$ is Shannon’s binary entropy function, $\alpha \in$ $( 0 , 1 ) ^ { n }$ is a variational parameter defined for each training example, and $\odot$ denotes the element-wise vector product. Crucially, the equality holds when the maximum of r.h.s. w.r.t $_ \alpha$ is achieved at $\begin{array} { r } { \pmb { \alpha } ^ { * } = \frac { \bar { { \partial \mathcal { L } } } } { \partial ( \mathbf { Y } \hat { \mathbf { y } } ) ^ { T } } } \end{array}$ , which leads to the following optimization problem,
+
+$$
+\operatorname* { m i n } _ { \pmb { \theta } } \mathcal { L } \left( \pmb { \theta } \right) = \operatorname* { m i n } _ { \pmb { \theta } } \operatorname* { m a x } _ { \pmb { \alpha } } \left( \mathbf { 1 } \cdot H ( \pmb { \alpha } ) - \pmb { \alpha } \mathbf { Y } \hat { \mathbf { y } } + \frac { \lambda } { 2 } \| \pmb { \theta } \| ^ { 2 } \right) ,
+$$
+
+where the order of min and max can be swapped (see Lemma 3 of [50]). Since the neural network’s output is approximated by a linear function of $\pmb \theta$ , the minimization can be performed analytically with an critical value $\pmb { \theta } _ { . } ^ { \ast T } = \triangleq \frac { 1 } { \lambda } \pmb { \alpha } \mathbf { Y } \pmb { \Phi } _ { 0 }$ , given by a weighted sum of the training examples. This results in the following maximization problem on the dual variable, i.e., $\operatorname* { m i n } _ { \theta } { \mathcal { L } } \left( \theta \right)$ is equivalent to,
+
+$$
+\operatorname* { m i n } _ { \pmb { \theta } } \mathcal { L } \left( \pmb { \theta } \right) = \operatorname* { m a x } _ { \pmb { \alpha } } \left( \mathbf { 1 } \cdot H ( \pmb { \alpha } ) - \frac { 1 } { 2 \lambda } \pmb { \alpha } \mathbf { Y } \pmb { \Phi } _ { 0 } \pmb { \Phi } _ { 0 } ^ { T } \mathbf { Y } ^ { T } \pmb { \alpha } ^ { T } \right) .
+$$
+
+By applying continuous-time gradient ascent on this optimization problem, we derive an autonomous differential equation for the evolution of $_ { \pmb { \alpha } }$ , which can be written in terms of features (see Definition 1),
+
+$$
+\dot { \pmb { \alpha } } = \eta \left( - \log \pmb { \alpha } + \log \left( \mathbf { 1 } - \pmb { \alpha } \right) - \frac { 1 } { \lambda } \pmb { \alpha } \mathbf { U } \mathbf { S } ^ { 2 } \mathbf { U } ^ { T } \right) ,
+$$
+
+where $\eta$ is the learning rate (see $\mathrm { S M } \mathrm { C } . 1$ for more details). For this dynamical system, we see that the logarithm term acts as barriers that keep $\alpha _ { i } \in ( 0 , 1 )$ . The other term depends on the matrix $\mathbf { U S ^ { 2 } U } ^ { T }$ , which is positive definite, and thus pushes the system towards the origin and therefore drives learning.
+
+When $\lambda \ll s _ { k } ^ { 2 }$ , where $k$ is an index over the singular values, the linear term dominates Eq. 9, and the fixed point is drawn closer towards the origin. Approximating dynamics with a first order Taylor expansion around the origin of the second term in Eq. 9, we get
+
+$$
+\dot { \boldsymbol { \alpha } } \approx \eta \left( - \log \boldsymbol { \alpha } - \frac { 1 } { \lambda } \boldsymbol { \alpha } \mathbf { U } \left( \mathbf { S } ^ { 2 } + \lambda \mathbf { I } \right) \mathbf { U } ^ { T } \right) ,
+$$
+
+with stability given by the following theorem with proof in $\mathbf { S M C }$ .
+
+Theorem 1. Any fixed points of the system in Eq. 10 is attractive in the domain $\alpha _ { i } \in ( 0 , 1 )$ .
+
+At the fixed point $\ b { \alpha } ^ { * }$ , corresponding to the optimum of Eq. 8, the feature response of the neural network is given by,
+
+$$
+\mathbf { z } ^ { \ast } = \frac { 1 } { \lambda } \mathbf { S } ^ { 2 } \mathbf { U } ^ { T } \pmb { \alpha } ^ { \ast T } .
+$$
+
+See App. A for further discussions on the distinction between "feature space" and "parameter space". Below, we study how the strength of one feature could impact the response of the network to another feature which leads to GS.
+
+# 3.3 Gradient Starvation Regime
+
+In general, we do not expect to find an analytical solution for the dynamics of the coupled non-linear dynamical system of Eq. 10. However, there are at least two cases where a decoupled form for the dynamics allows to find an exact solution. We first introduce these cases and then study their perturbation to outline general lessons.
+
+1. If the matrix of singular values $\mathbf { S } ^ { 2 }$ is proportional to the identity: This is the case where all the features have the same strength $s ^ { 2 }$ . The fixed points are then given by,
+
+$$
+\alpha _ { i } ^ { * } = \frac { \lambda \mathcal { W } ( \lambda ^ { - 1 } s ^ { 2 } + 1 ) } { s ^ { 2 } + \lambda } , \qquad z _ { j } ^ { * } = \frac { s ^ { 2 } \mathcal { W } ( \lambda ^ { - 1 } s ^ { 2 } + 1 ) } { s ^ { 2 } + \lambda } \sum _ { i } u _ { i j } ,
+$$
+
+where $\mathcal { W }$ is the Lambert W function.
+
+2. If the matrix $\mathbf { U }$ is a permutation matrix: This is the case in which each feature is associated with a single example only. The fixed points are then given by,
+
+$$
+\alpha _ { i } ^ { * } = \frac { \lambda \mathcal { W } ( \lambda ^ { - 1 } s _ { i } ^ { 2 } + 1 ) } { s _ { i } ^ { 2 } + \lambda } , \ ~ \ z _ { j } ^ { * } = \frac { s _ { i } ^ { 2 } \mathcal { W } ( \lambda ^ { - 1 } s _ { i } ^ { 2 } + 1 ) } { s _ { i } ^ { 2 } + \lambda } .
+$$
+
+To study a minimal case of starvation, we consider a variation of case 2 with the following assumption which implies that each feature is not associated with a single example anymore.
+
+Lemma 1. Assume $\mathbf { U }$ is a perturbed identity matrix (a special case of a permutation matrix) in which the off-diagonal elements are proportional to a small parameter $\delta > 0$ . Then, the fixed point of the dynamical system in Eq. 10 can be approximated by,
+
+$$
+\begin{array} { r } { { \pmb \alpha } ^ { * } = ( 1 - \log \left( { \pmb \alpha } _ { 0 } ^ { * } \right) ) \left[ { \pmb A } + d i a g \left( { \pmb \alpha } _ { 0 } ^ { * } ^ { - 1 } \right) \right] ^ { - 1 } , } \end{array}
+$$
+
+where $\mathbf { A } = \lambda ^ { - 1 } \mathbf { U } ( \mathbf { S } ^ { 2 } + \lambda \mathbf { I } ) \mathbf { U } ^ { T }$ and $\alpha _ { 0 } ^ { * }$ is the fixed point of the uncoupled system with $\delta = 0$
+
+For sake of ease of derivations, we consider the two dimensional case where,
+
+$$
+\mathbf { U } = \left( \begin{array} { c c } { \sqrt { 1 - \delta ^ { 2 } } } & { - \delta } \\ { \delta } & { \sqrt { 1 - \delta ^ { 2 } } } \end{array} \right) ,
+$$
+
+which is equivalent to a $U$ matrix with two blocks of features with no intra-block coupling and $\delta$ amount of inter-block coupling.
+
+Theorem 2 (Gradient Starvation Regime). Consider a neural network in the linear regime, trained under cross-entropy loss for a binary classification task. With definition $^ { l }$ , assuming coupling between features 1 and 2 as in Eq. 15 and $s _ { 1 } ^ { 2 } > s _ { 2 } ^ { 2 }$ , we have,
+
+$$
+\frac { \mathrm { d } z _ { 2 } ^ { * } } { \mathrm { d } s _ { 1 } ^ { 2 } } < 0 ,
+$$
+
+which implies GS.
+
+While Thm. 2 outlines conditions for GS in two dimensional feature space, we note that the same rationale naturally extends to higher dimensions, where GS is defined pairwise over feature directions. For a classification task, Thm. 2 indicates that gradient starvation occurs when the data admits different feature strengths, and coupled learning dynamics. GS is thus naturally expected with cross-entropy loss. Its detrimental effects however (as outlined in Sect. 2) arise in settings with large discrepancies between feature strengths, along with network connectivity that couples these features’ directions. This phenomenon readily extends to multi-class settings, and we validate this case with experiments in Sect. 4. Next, we introduce a simple regularizer that encourages feature decoupling, thus mitigating GS by insulating strong features from weaker ones.
+
+# 3.4 Spectral Decoupling
+
+By tracing back the equations of the previous section, one may realize that the term $U ^ { T } S ^ { 2 } U$ in Eq. 9 is not diagonal in the general case, and consequently introduces coupling between $\alpha _ { i }$ ’s and hence, between the features $z _ { i }$ ’s. We would like to discourage solutions that couple features in this way. To that end, we introduce a simple regularizer: Spectral Decoupling (SD). SD replaces the general L2 weight decay term in Eq. 5 with an L2 penalty exclusively on the network’s logits, yielding
+
+$$
+\mathcal { L } \left( \pmb { \theta } \right) = \mathbf { 1 } \cdot \log \left[ 1 + \exp \left( - \mathbf { Y } \hat { \mathbf { y } } \right) \right] + \frac { \lambda } { 2 } \| \hat { \mathbf { y } } \| ^ { 2 } .
+$$
+
+Repeating the same analysis steps taken above, but with SD instead of general L2 penalty, the critical value for $\pmb { \theta } ^ { * }$ becomes $\begin{array} { r } { \pmb { \theta } ^ { \ast } = \frac { 1 } { \lambda } \pmb { \alpha } \pmb { Y } \pmb { \Phi } _ { 0 } V \mathbf { S } ^ { - 2 } V ^ { T } } \end{array}$ . This new expression for $\pmb { \theta } ^ { * }$ results in the following modification of Eq. 9,
+
+$$
+\dot { \alpha } = \eta \left( \log \frac { \mathbf { 1 } - \alpha } { \alpha } - \frac { 1 } { \lambda } \alpha \mathbf { U } \mathbf { S } ^ { 2 } \mathbf { S } ^ { - 2 } \mathbf { U } ^ { T } \right) = \eta \left( \log \frac { \mathbf { 1 } - \alpha } { \alpha } - \frac { 1 } { \lambda } \alpha \right) ,
+$$
+
+where as earlier, log and division are taken element-wise on the coordinates of $_ { \pmb { \alpha } }$
+
+Note that in contrast to Eq. 9 the matrix multiplication involving $U$ and $S$ in Eq. 18 cancels out, leaving $\alpha _ { i }$ independent of other $\alpha _ { j \neq i }$ ’s. We point out this is true for any initial coupling, without simplifying assumptions. Thus, a simple penalty on output weights promotes decoupled dynamics across the dual parameter $\alpha _ { i }$ ’s, which track learning dynamics of feature responses (see Eq. 7). Together with Thm. 2, Eq. 18 suggests SD should mitigate GS and promote balanced learning dynamics across features. We now verify this in numerical experiments. For further intuition, we provide a simple experiment, summarized in Fig. 5, where directly visualizes the primal vs. the dual dynamics as well as the effect of the proposed spectral decoupling method.
+
+# 4 Experiments
+
+The experiments presented here are designed to outline the presence of GS and its consequences, as well as the efficacy of our proposed regularization method to alleviate them. Consequently, we highlight that achieving state-of-the-art results is not the objective. For more details including the scheme for hyper-parameter tuning, see App. B.
+
+# 4.1 Two-Moon classification and the margin
+
+Recall the simple 2-D classification task between red and blue data points in Fig. 1. Fig. 1 (c) demonstrates the learned decision boundary when SD is used. SD leads to learning a curved decision boundary with a larger margin in the input space. See App. B for additional details and experiments.
+
+# 4.2 CIFAR classification and adversarial robustness
+
+To study the classification margin in deeper networks, we conduct a classification experiment on CIFAR-10, CIFAR-100, and CIFAR-2 (cats vs dogs of CIFAR-10) [57] using a convolutional network with ReLU non-linearity. Unlike linear models, the margin to a non-linear decision boundary cannot be computed analytically. Therefore, following the approach in [72], we use "the norm of inputdisturbance required to cross the decision boundary" as a proxy for the margin. The disturbance on the input is computed by projected gradient descent (PGD) [84], a well-known adversarial attack.
+
+Table 1: Table compares adversarial robustness of ERM (vanilla cross-entropy) vs SD with a CNN trained on CIFAR-2, 10, and 100 (setup of [72]). SD consistently achieves a better OOD performance.   
+
+<table><tr><td>Dataset</td><td>Method</td><td>Train*</td><td>Test IID</td><td>Test OOD†</td></tr><tr><td rowspan="2">Cifar-2</td><td>w/o SD</td><td></td><td>100.0% ±0.0 95.2%±0.12</td><td>42.3% ±3.0</td></tr><tr><td></td><td></td><td>w/ SD(a=0.01)100.0%±0.0 95.3%±0.17</td><td>69.7% ± 2.9</td></tr><tr><td rowspan="2">Cifar-10</td><td>w/o SD</td><td>99.9% ± 0.01</td><td>92.8%±0.15</td><td>30.1% ± 2.1</td></tr><tr><td></td><td></td><td>w/ SD(=0.01)99.9%±0.01 92.9% ±0.16</td><td>67.7% ± 1.5</td></tr><tr><td rowspan="2">Cifar-100</td><td>w/o SD</td><td></td><td>99.7% ± 0.01 69.2% ±0.29</td><td>14.3% ± 2.0</td></tr><tr><td></td><td></td><td>w/SD(a=0.05)99.7%±0.0270.5%±0.26</td><td>24.9% ± 1.9</td></tr></table>
+
+† Accuracy (± std) for 10 runs.
+
+![](images/bf195fd7cc5efdd1fa50f433f2b3afcfca326e622b21c20b2e591316e226f770.jpg)  
+Figure 2: The plot shows the cumulative distribution function (CDF) of the margin for the CIFAR-2 binary classification. SD appears to improve the margin considerably.
+
+Table 1 includes the results for IID (original test set) and OOD (perturbed test set by $\epsilon _ { \mathrm { P G D } } = 0 . 0 5 )$ . Fig. 2 shows the percentange of mis-classifications as the norm of disturbance is increased for the Cifar-2 dataset. This plot can be interpreted as the cumulative distribution function (CDF) of the margin and hence a lower curve reads as a more robust network with a larger margin. This experiment suggests that when trained with vanilla cross-entropy, even slight disturbances in the input deteriorates the network’s classification accuracy. That is while spectral decoupling (SD) improves the margin considerably. Importantly, this improvement in robustness does not seem to compromise the noise-free test performance. It should also be highlighted that SD does not explicitly aim at maximizing the margin and the observed improvement is in fact a by-product of decoupled learning of latent features. See Section 5 for a discussion on why cross-entropy results in a poor margin while being considered a max-margin classifier in the literature [94].
+
+# 4.3 Colored MNIST with color bias
+
+We conduct experiments on the Colored MNIST Dataset, proposed in [9]. The task is to predict binary labels $y = - 1$ for digits 0 to 4 and $y = + 1$ for digits 5 to 9. A color channel (red, green) is artificially added to each example to deliberately impose a spurious correlation between the color and the label. The task has three environments:
+
+• Training env. 1: Color is correlated with the labels with 0.9 probability. • Training env. 2: Color is correlated with the labels with 0.8 probability. • Testing env.: Color is correlated with the labels with 0.1 probability (0.9 reversely corre
+
+Because of the opposite correlation between the color and the label in the test set, only learning to classify based on color would be disastrous at testing. For this reason, Empirical Risk Minimization (ERM) performs very poorly on the test set $( 2 3 . 7 \%$ accuracy) as shown in Tab. 2.
+
+<table><tr><td>Method</td><td>Train Accuracy</td><td>Test Accuracy</td></tr><tr><td>ERM(Vanilla Cross-Entropy)</td><td>91.1 % (±0.4)</td><td>23.7 % (±0.8)</td></tr><tr><td>REx[59]</td><td>71.5 % (±1.0)</td><td>68.7% (±0.9)</td></tr><tr><td>IRM[9]</td><td>70.5% (±0.6)</td><td>67.1 % (±1.4)</td></tr><tr><td>SD (this work)</td><td>70.0 % (±0.9)</td><td>68.4% (±1.2)</td></tr><tr><td>Oracle - (grayscale images)</td><td>73.5 % (±0.2)</td><td>73.0 % (±0.4)</td></tr><tr><td>RandomGuess</td><td>50%</td><td>50%</td></tr></table>
+
+Table 2: Test accuracy on test examples of the Colored MNIST after training for 1k epochs. The standard deviation over 10 runs is reported in parenthesis. ERM stands for the empirical risk minimization. Oracle is an ERM trained on grayscale images. Note that due to $25 \%$ label noise, a hypothetical optimum achieves $75 \%$ accuracy (the upper bound).
+
+Invariant Risk Minimization (IRM) [9] on the other hand, performs well on the test set with $( 6 7 . 1 \%$ accuracy). However, IRM requires access to multiple (two in this case) separate training environments with varying amount of spurious correlations. IRM uses the variance between environments as a signal for learning to be “invariant” to spurious correlations. Risk Extrapolation (REx) [59] is a related training method that encourages learning invariant representations. Similar to IRM, it requires access to multiple training environments in order to quantify the concept of “invariance”.
+
+SD achieves an accuracy of $6 8 . 4 \%$ . Its performance is remarkable because unlike IRM and REx, SD does not require access to multiple environments and yet performs well when trained on a single environment (in this case the aggregation of both of the training environments).
+
+A natural question that arises is “How does SD learn to ignore the color feature without having access to multiple environments?” The short answer is that it does not! In fact, we argue that SD learns the color feature but it also learns other predictive features, i.e., the digit shape features. At test time, the predictions resulting from the shape features prevail over the color feature. To validate this hypothesis, we study a trained model with each of these methods (ERM, IRM, SD) on four variants of the test environment: 1) grayscale-digits: No color channel is provided and the network should rely on shape features only. 2) colored-digits: Both color and digit are provided however the color is negatively correlated (opposite of the training set) with the label. 3) grayscaleblank: All images are grayscale and blank and hence do not provide any information. 4) colored-blank: Digit features are removed and only the color feature is kept, also with reverse label compared to training. Fig. 3 summarizes the results. For more discussions see SM B.
+
+As a final remark, we should highlight that, by design, this task assumes access to the test environment for hyperparameter tuning for all the reported methods. This is not a valid assumption in general, and hence the results should be only interpreted as a probe that shows that SD could provide an important level of control over what features are learned.
+
+![](images/d0fa5d396174a94eb275513da009f1f33178a40f2dbc241ce7dfa391f7e566f2.jpg)  
+Figure 3: Diagram comparing ERM, SD, and IRM on four different test environments on which we evaluate a pre-trained model. Top and bottom rows show the accuracy and the entropy (inverse of confidence), respectively. Analysis: Compare three values of $\mathfrak { C } \sharp \sharp \sharp \sharp \sharp \cdot$ , 9.4 % , and $4 9 . 6 \%$ : Both ERM and SD have learned the color feature but since it is inversely correlated with the label, when only the color feature is provided, as expected both ERM and SD performs poorly. Now compare $\textcircled { 1 } \textcircled { 1 }$ and $0 . 4 1$ : Although both ERM and SD have learned the color feature, ERM is much more confident on its predictions (zero entropy). As a consequence, when digit features are provided along with the color feature (colored-digit environment), ERM still performs poorly $( \overbrace { 2 3 . 9 \mathrm { ~ \% ~ } } )$ but SD achieves significantly better results $( 6 7 . 2 \% )$ ). IRM ignores the color feature altogether but it requires access to multiple training environments.
+
+![](images/78aab33fb5d05d81db549ed8560e9bd995cca1540e7ae465d6c4ea573f439933.jpg)  
+Figure 4: CelebA: blond vs dark hair classification. The HairColor and the Gender are spuriously correlated which leads to poor OOD performance with ERM, however SD significantly improves performance. ERM’s worst group accuracy is significantly lower than SD.
+
+Table 3: CelebA: blond vs dark hair classification with spurious correlation. We report test performance over ten runs. SD significantly improves upon ERM. ∗Group DRO [89] requires explicit information about the spurious correlation. LfF [71] requires simultaneous training of two networks.   
+
+<table><tr><td>Method</td><td>Average Acc.</td><td>Worst Group Acc.</td></tr><tr><td>ERM</td><td>94.61 % (±0.67)</td><td>40.35 % (±1.68)</td></tr><tr><td>SD (this work)</td><td>91.64 % (±0.61)</td><td>83.24 % (±2.01)</td></tr><tr><td>LfF</td><td>N/A</td><td>81.24 % (±1.38)</td></tr><tr><td>Group DRO*</td><td>91.76 % (±0.28)</td><td>87.78 % (±0.96)</td></tr></table>
+
+# 4.4 CelebA with gender bias
+
+The CelebA dataset [65] contains $1 6 2 \mathrm { k }$ celebrity faces with binary attributes associated with each image. Following the setup of [89], the task is to classify images with respect to their hair color into two classes of blond or dark hair. However, the Gender $\in$ {Male, Female} is spuriously correlated with the $\mathtt { H a i r C o l o r } \in \{ \mathtt { B l o n d } , \mathtt { D a r k } \}$ in the training data. The rarest group which is blond males represents only $0 . 8 5 \%$ of the training data (1387 out of $1 6 2 \mathrm { k }$ examples). We train a ResNet-50 model [38] on this task. Tab. 3 summarizes the results and compares the performance of several methods. A model with vanilla cross-entropy (ERM) appears to generalize well on average but fails to generalize to the rarest group (blond males) which can be considered as “weakly" out-of-distribution (OOD). Our proposed SD improves the performance more than twofold. It should be highlighted that for this task, we use a variant of SD in which, $\frac { \lambda } { 2 } | | \hat { y } - \gamma | | _ { 2 } ^ { 2 }$ is added to the original cross-entropy loss. The hyper-parameters $\lambda$ and $\gamma$ are tuned separately for each class (a total of four hyper-parameters). This variant of SD does provably decouple the dynamics too but appears to perform better than the original SD in Eq. 17 in this task.
+
+Other proposed methods presented in Tab. 3 also show significant improvements on the performance of the worst group accuracy. The recently proposed “Learning from failure” (LfF) [71] achieves comparable results to SD, but it requires simultaneous training of two networks. Group DRO [89] is another successful method for this task. However, unlike SD, Group DRO requires explicit information about the spuriously correlated attributes. In most practical tasks, information about the spurious correlations is not provided and, dependence on the spurious correlation goes unrecognized.2
+
+# 5 Related Work and Discussion
+
+Here, we discuss the related work. Due to space constraints, further discussions are in App. A.
+
+On learning dynamics and Loss Choice. Several works including [90, 91, 1, 60] investigate the dynamics of deep linear networks trained with squared-error loss. Different decompositions of the learning process for neural networks have been used: [83, 104, 87, 105] study the learning in the Fourier domain and show that low-frequency functions are learned earlier than high-frequency ones. [90, 2, 32] provide closed-form equations for the dynamics of linear networks in terms of the principal components of the input covariance matrix. More recently, with the introduction of neural tangent kernel (NTK) [52, 62], a new line of research is to study the convergence properties of gradient descent [e.g. 8, 69, 25, 29, 7, 44, 33, 110, 11, 99]. Among them, [12, 106, 18, 22] decompose the learning process along the principal components of the NTK. The message in these works is that the training process can be decomposed into independent learning dynamics along the orthogonal directions.
+
+Most of the studies mentioned above focus on the particular squared-error loss. For a linearized network, the squared-error loss results in linear learning dynamics, which often admit an analytical solution. However, the de-facto loss function for many of the practical applications of neural networks is the cross-entropy. Using the cross-entropy as the loss function leads to significantly more complicated and non-linear dynamics, even for a linear neural network. In this work, our focus was the cross-entropy loss.
+
+On reliance upon spurious correlations and robustness. In the context of robustness in neural networks, state-of-the-art neural networks appear to naturally focus on low-level superficial correlations rather than more abstract and robustly informative features of interest (e.g. [30]). As we argue in this work, Gradient Starvation is likely an important factor contributing to this phenomenon and can result in adversarial vulnerability. There is a rich research literature on adversarial attacks and neural networks’ vulnerability [96, 34, 48, 67, 5, 47]. Interestingly, [73], [72] and [51] draw a similar conclusion and argue that “an insufficiency of the cross-entropy loss” causes excessive invariances to predictive features. Perhaps [92] is the closest to our work in which authors study the simplicity bias (SB) in stochastic gradient descent. They demonstrate that neural networks exhibit extreme bias that could lead to adversarial vulnerability.
+
+On implicit bias. Despite being highly-overparameterized, modern neural networks seem to generalize very well [108]. Modern neural networks generalize surprisingly well in numerous machine tasks. This is despite the fact that neural networks typically contain orders of magnitude more parameters than the number of examples in a training set and have sufficient capacity to fit a totally randomized dataset perfectly [108]. The widespread explanation is that the gradient descent has a form of implicit bias towards learning simpler functions that generalize better according to Occam’s razor. Our exposition of GS reinforces this explanation. In essence, when training and test data points are drawn from the same distribution, the top salient features are predictive in both sets. We conjecture that in such a scenario, by not learning the less salient features, GS naturally protects the network from overfitting.
+
+The same phenomenon is referred to as implicit bias, implicit regularization, simplicity bias and spectral bias in several works [83, 75, 36, 74, 70, 53, 94, 10, 13, 35, 82, 66].
+
+As an active line of research, numerous studies have provided different explanations for this phenomenon. For example, [70] justifies the implicit bias of neural networks by showing that stochastic gradient descent learns simpler functions first. [15, 78] suggests that a form of implicit regularization is induced by an alignment between NTK’s principal components and only a few task-relevant directions. Several other works such as [20, 35, 94, 25] recognize the convergence of gradient descent to maximum-margin solution as the essential factor for the generalizability of neural networks. It should be stressed that these work refer to the margin in the hidden space and not in the input space as pointed out in [55]. Indeed, as observed in our experiments, the maximum-margin classifier in the hidden space can be achieved at the expense of a small margin in the input space.
+
+On Gradient Starvation and no free lunch theorem. The no free lunch theorem [93, 102] states that “learning is impossible without making assumptions about training and test distributions”. Perhaps, the most commonly used assumption of machine learning is the i.i.d. assumption [98], which assumes that training and test data are identically distributed. However, in general, this assumption might not hold, and in many practical applications, there are predictive features in the training set that do not generalize to the test set. A natural question that arises is how to favor generalizable features over spurious features? The most common approaches include data augmentation, controlling the inductive biases, using regularizations, and more recently training using multiple environments.
+
+Here, we would like to elaborate on an interesting thought experiment of [79]: Suppose a neural network is provided with a chess book containing examples of chess games with the best movements indicated by a red arrow. The network can take two approaches: 1) learn how to play chess, or 2) learn just the red arrows. Either of these solutions results in zero training loss on the games in the book while only the former is generalizable to new games. With no external knowledge, the network typically learns the simpler solution.
+
+Recent work aims to leverage the invariance principle across several environments to improve robust learning. This is akin to present several chess books to a network, each with markings indicating the best moves for different sets of games. In several studies [9, 59, 79, 3], methods are developed to aggregate information from multiple training environments in a way that favors the generalizable / domain-agnostic / invariant solution. We argue that even with having access to only one training environment, there is useful information in the training set that fails to be discovered due to Gradient Starvation. The information on how to actually play chess is already available in any of the chess books. Still, as soon as the network learns the red arrows, the network has no incentive for further learning. Therefore, learning the red arrows is not an issue per se, but not learning to play chess is.
+
+Gradient Starvation: friend or foe? Here, we would like to remind the reader that GS can have both adverse and beneficial consequences. If the learned features are sufficient to generalize to the test data, gradient starvation can be viewed as an implicit regularizer. Otherwise, Gradient Starvation could have an unfavorable effect, which we observe empirically when some predictive features fail to be learned. A better understanding and control of Gradient Starvation and its impact on generalization offers promising avenues to address this issue with minimal assumptions. Indeed, our Spectral Decoupling method requires an assumption about feature imbalance but not to pinpoint them exactly, relying on modulated learning dynamics to achieve balance.
+
+GS social impact Modern neural networks are being deployed extensively in numerous machine learning tasks. Our models are used in critical applications such as autonomous driving, medical prediction, and even justice system where human lives are at stake. However, neural networks appear to base their predictions on superficial biases in the dataset. Unfortunately, biases in datasets could be neglected and pose negative impacts on our society. In fact, our Celeb-A experiment is an example of the existence of such a bias in the data. As shown in the paper, the gender-specific bias could lead to a superficial high performance and is indeed very hard to detect. Our analysis, although mostly on the theory side, could pave the path for researchers to build machine learning systems that are robust to biases and helps towards fairness in our predictions.
+
+# 6 Conclusion
+
+In this paper, we formalized Gradient Starvation (GS) as a phenomenon that emerges when training with cross-entropy loss in neural networks. By analyzing the dynamical system corresponding to the learning process in a dual space, we showed that GS could slow down the learning of certain features, even if they are present in the training set. We derived spectral decoupling (SD) regularization as a possible remedy to GS.
+
+# Acknowledgments and Disclosure of Funding
+
+The authors are grateful to Samsung Electronics Co., Ldt., CIFAR, and IVADO for their funding and Calcul Québec and Compute Canada for providing us with the computing resources. We would further like to acknowledge the significance of discussions and supports from Reyhane Askari Hemmat and Faruk Ahmed. MP would like to thank Aristide Baratin, Kostiantyn Lapchevskyi, Seyed Mohammad Mehdi Ahmadpanah, Milad Aghajohari, Kartik Ahuja, Shagun Sodhani, and Emmanuel Bengio for their invaluable help.
+
+# References
+
+[1] Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017.   
+[2] Madhu S Advani, Andrew M Saxe, and Haim Sompolinsky. High-dimensional dynamics of generalization error in neural networks. Neural Networks, 2020.   
+[3] Kartik Ahuja, Karthikeyan Shanmugam, and Amit Dhurandhar. Linear regression games: Convergence guarantees to approximate out-of-distribution solutions. arXiv preprint arXiv:2010.15234, 2020. [4] Kartik Ahuja, Karthikeyan Shanmugam, Kush Varshney, and Amit Dhurandhar. Invariant risk minimization games. arXiv preprint arXiv:2002.04692, 2020.   
+[5] Naveed Akhtar and Ajmal Mian. Threat of adversarial attacks on deep learning in computer vision: A survey. IEEE Access, 6:14410–14430, 2018.   
+[6] Adelin Albert and John A Anderson. On the existence of maximum likelihood estimates in logistic regression models. Biometrika, 71(1):1–10, 1984.   
+[7] Zeyuan Allen-Zhu, Yuanzhi Li, and Yingyu Liang. Learning and generalization in overparameterized neural networks, going beyond two layers. In Advances in neural information processing systems, pages 6158–6169, 2019.   
+[8] Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via over-parameterization. In International Conference on Machine Learning, pages 242–252. PMLR, 2019.   
+[9] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   
+[10] Sanjeev Arora, Nadav Cohen, Wei Hu, and Yuping Luo. Implicit regularization in deep matrix factorization. In Advances in Neural Information Processing Systems, pages 7413–7424, 2019.   
+[11] Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Russ R Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. In Advances in Neural Information Processing Systems, pages 8141–8150, 2019.   
+[12] Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, and Ruosong Wang. Fine-grained analysis of optimization and generalization for overparameterized two-layer neural networks. arXiv preprint arXiv:1901.08584, 2019.   
+[13] Devansh Arpit, Stanisław Jastrz˛ebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. arXiv preprint arXiv:1706.05394, 2017.   
+[14] Nicholas Baker, Hongjing Lu, Gennady Erlikhman, and Philip J Kellman. Deep convolutional networks do not classify based on global object shape. PLoS computational biology, 14(12):e1006613, 2018.   
+[15] Aristide Baratin, Thomas George, César Laurent, R Devon Hjelm, Guillaume Lajoie, Pascal Vincent, and Simon Lacoste-Julien. Implicit regularization in deep learning: A view from function space. arXiv preprint arXiv:2008.00938, 2020.   
+[16] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), pages 456–473, 2018.   
+[17] Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine translation. arXiv preprint arXiv:1711.02173, 2017.   
+[18] Alberto Bietti and Julien Mairal. On the inductive bias of neural tangent kernels. In Advances in Neural Information Processing Systems, pages 12893–12904, 2019.   
+[19] Wieland Brendel and Matthias Bethge. Approximating cnns with bag-of-local-features models works surprisingly well on imagenet. arXiv preprint arXiv:1904.00760, 2019.   
+[20] Alon Brutzkus, Amir Globerson, Eran Malach, and Shai Shalev-Shwartz. Sgd learns overparameterized networks that provably generalize on linearly separable data. arXiv preprint arXiv:1710.10174, 2017.   
+[21] Christopher JC Burges and David J Crisp. Uniqueness of the svm solution. Advances in neural information processing systems, 12:223–229, 2000.   
+[22] Yuan Cao, Zhiying Fang, Yue Wu, Ding-Xuan Zhou, and Quanquan Gu. Towards understanding the spectral bias of deep learning. arXiv preprint arXiv:1912.01198, 2019.   
+[23] Yuan Cao and Quanquan Gu. Generalization bounds of stochastic gradient descent for wide and deep neural networks. In Advances in Neural Information Processing Systems, pages 10836–10846, 2019.   
+[24] Zixiang Chen, Yuan Cao, Quanquan Gu, and Tong Zhang. A generalized neural tangent kernel analysis for two-layer neural networks. arXiv preprint arXiv:2002.04026, 2020.   
+[25] Lenaic Chizat and Francis Bach. A note on lazy training in supervised differentiable programming. arXiv preprint arXiv:1812.07956, 1, 2018.   
+[26] Remi Tachet des Combes, Mohammad Pezeshki, Samira Shabanian, Aaron Courville, and Yoshua Bengio. On the learning dynamics of deep neural networks. arXiv preprint arXiv:1809.06848, 2018.   
+[27] Thomas M Cover. Geometrical and statistical properties of systems of linear inequalities with applications in pattern recognition. IEEE transactions on electronic computers, 0(3):326–334, 1965.   
+[28] Simon S Du, Wei Hu, and Jason D Lee. Algorithmic regularization in learning deep homogeneous models: Layers are automatically balanced. In Advances in Neural Information Processing Systems, pages 384–395, 2018.   
+[29] Simon S Du, Xiyu Zhai, Barnabas Poczos, and Aarti Singh. Gradient descent provably optimizes over-parameterized neural networks. arXiv preprint arXiv:1810.02054, 2018.   
+[30] Robert Geirhos, Jörn-Henrik Jacobsen, Claudio Michaelis, Richard Zemel, Wieland Brendel, Matthias Bethge, and Felix A Wichmann. Shortcut learning in deep neural networks. arXiv preprint arXiv:2004.07780, 2020.   
+[31] Thomas George. Nngeometry: Easy and fast fisher information matrices and neural tangent kernels in pytorch. 0, 2020.   
+[32] Gauthier Gidel, Francis Bach, and Simon Lacoste-Julien. Implicit regularization of discrete gradient dynamics in linear neural networks. In Advances in Neural Information Processing Systems, pages 3202–3211, 2019.   
+[33] Sebastian Goldt, Madhu Advani, Andrew M Saxe, Florent Krzakala, and Lenka Zdeborová. Dynamics of stochastic gradient descent for two-layer neural networks in the teacher-student setup. In Advances in Neural Information Processing Systems, pages 6981–6991, 2019.   
+[34] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.   
+[35] Suriya Gunasekar, Jason D Lee, Daniel Soudry, and Nati Srebro. Implicit bias of gradient descent on linear convolutional networks. In Advances in Neural Information Processing Systems, pages 9461–9471, 2018.   
+[36] Suriya Gunasekar, Blake E Woodworth, Srinadh Bhojanapalli, Behnam Neyshabur, and Nati Srebro. Implicit regularization in matrix factorization. In Advances in Neural Information Processing Systems, pages 6151–6159, 2017.   
+[37] Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel R Bowman, and Noah A Smith. Annotation artifacts in natural language inference data. arXiv preprint arXiv:1803.02324, 2018.   
+[38] 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, pages 770–778, 2016.   
+[39] Christina Heinze-Deml and Nicolai Meinshausen. Conditional variance penalties and domain shift robustness. arXiv preprint arXiv:1710.11469, 2017.   
+[40] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019.   
+[41] Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-ofdistribution examples in neural networks. arXiv preprint arXiv:1610.02136, 2016.   
+[42] Katherine L Hermann and Andrew K Lampinen. What shapes feature representations? exploring datasets, architectures, and training. arXiv preprint arXiv:2006.12433, 2020.   
+[43] Cho-Jui Hsieh, Kai-Wei Chang, Chih-Jen Lin, S Sathiya Keerthi, and Sellamanickam Sundararajan. A dual coordinate descent method for large-scale linear svm. In Proceedings of the 25th international conference on Machine learning, pages 408–415, 2008.   
+[44] Jiaoyang Huang and Horng-Tzer Yau. Dynamics of deep neural networks and neural tangent hierarchy. arXiv preprint arXiv:1909.08156, 2019.   
+[45] Kaixuan Huang, Yuqing Wang, Molei Tao, and Tuo Zhao. Why do deep residual networks generalize better than deep feedforward networks?—a neural tangent kernel perspective. Advances in Neural Information Processing Systems, 33, 2020.   
+[46] Like Hui and Mikhail Belkin. Evaluation of neural architectures trained with square loss vs cross-entropy in classification tasks. arXiv preprint arXiv:2006.07322, 2020.   
+[47] Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018.   
+[48] 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, pages 125–136, 2019.   
+[49] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.   
+[50] Tommi S Jaakkola and David Haussler. Probabilistic kernel regression models. In AISTATS, 1999.   
+[51] Jörn-Henrik Jacobsen, Jens Behrmann, Richard Zemel, and Matthias Bethge. Excessive invariance causes adversarial vulnerability. arXiv preprint arXiv:1811.00401, 2018.   
+[52] Arthur Jacot, Franck Gabriel, and Clément Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In Advances in neural information processing systems, pages 8571–8580, 2018.   
+[53] Ziwei Ji and Matus Telgarsky. The implicit bias of gradient descent on nonseparable data. In Conference on Learning Theory, pages 1772–1798, 2019.   
+[54] Jason Jo and Yoshua Bengio. Measuring the tendency of cnns to learn surface statistical regularities. arXiv preprint arXiv:1711.11561, 2017.   
+[55] Alexia Jolicoeur-Martineau and Ioannis Mitliagkas. Connections between support vector machines, wasserstein distance and gradient-penalty gans. arXiv preprint arXiv:1910.06922, 2019.   
+[56] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[57] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 0, 2009.   
+[58] Anders Krogh and John A Hertz. A simple weight decay can improve generalization. In Advances in neural information processing systems, pages 950–957, 1992.   
+[59] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.   
+[60] Andrew K Lampinen and Surya Ganguli. An analytic theory of generalization dynamics and transfer learning in deep linear networks. arXiv preprint arXiv:1809.10374, 2018.   
+[61] Sebastian Lapuschkin, Stephan Wäldchen, Alexander Binder, Grégoire Montavon, Wojciech Samek, and Klaus-Robert Müller. Unmasking clever hans predictors and assessing what machines really learn. Nature communications, 10(1):1–8, 2019.   
+[62] Jaehoon Lee, Lechao Xiao, Samuel Schoenholz, Yasaman Bahri, Roman Novak, Jascha Sohl-Dickstein, and Jeffrey Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. In Advances in neural information processing systems, pages 8570–8581, 2019.   
+[63] Kimin Lee, Kibok Lee, Honglak Lee, and Jinwoo Shin. A simple unified framework for detecting out-of-distribution samples and adversarial attacks. In Advances in Neural Information Processing Systems, pages 7167–7177, 2018.   
+[64] Shiyu Liang, Yixuan Li, and Rayadurgam Srikant. Enhancing the reliability of out-ofdistribution image detection in neural networks. arXiv preprint arXiv:1706.02690, 2017.   
+[65] 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.   
+[66] Cong Ma, Kaizheng Wang, Yuejie Chi, and Yuxin Chen. Implicit regularization in nonconvex statistical estimation: Gradient descent converges linearly for phase retrieval and matrix completion. In International Conference on Machine Learning, pages 3345–3354. PMLR, 2018.   
+[67] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.   
+[68] R Thomas McCoy, Ellie Pavlick, and Tal Linzen. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. arXiv preprint arXiv:1902.01007, 2019.   
+[69] Song Mei and Andrea Montanari. The generalization error of random features regression: Precise asymptotics and double descent curve. arXiv preprint arXiv:1908.05355, 2019.   
+[70] Preetum Nakkiran, Gal Kaplun, Dimitris Kalimeris, Tristan Yang, Benjamin L Edelman, Fred Zhang, and Boaz Barak. Sgd on neural networks learns functions of increasing complexity. arXiv preprint arXiv:1905.11604, 2019.   
+[71] Junhyun Nam, Hyuntak Cha, Sungsoo Ahn, Jaeho Lee, and Jinwoo Shin. Learning from failure: Training debiased classifier from biased classifier. arXiv preprint arXiv:2007.02561, 2020.   
+[72] Kamil Nar, Orhan Ocal, S Shankar Sastry, and Kannan Ramchandran. Cross-entropy loss and low-rank features have responsibility for adversarial examples. arXiv preprint arXiv:1901.08360, 2019.   
+[73] Kamil Nar and S Shankar Sastry. Persistency of excitation for robustness of neural networks. arXiv preprint arXiv:1911.01043, 2019.   
+[74] Behnam Neyshabur, Ryota Tomioka, Ruslan Salakhutdinov, and Nathan Srebro. Geometry of optimization and implicit regularization in deep learning. arXiv preprint arXiv:1705.03071, 2017.   
+[75] Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. arXiv preprint arXiv:1412.6614, 2014.   
+[76] Timothy Niven and Hung-Yu Kao. Probing neural network comprehension of natural language arguments. arXiv preprint arXiv:1907.07355, 2019.   
+[77] Luke Oakden-Rayner, Jared Dunnmon, Gustavo Carneiro, and Christopher Ré. Hidden stratification causes clinically meaningful failures in machine learning for medical imaging. In Proceedings of the ACM Conference on Health, Inference, and Learning, pages 151–159, 2020.   
+[78] Samet Oymak, Zalan Fabian, Mingchen Li, and Mahdi Soltanolkotabi. Generalization guarantees for neural networks via harnessing the low-rank structure of the jacobian. arXiv preprint arXiv:1906.05392, 2019.   
+[79] Giambattista Parascandolo, Alexander Neitz, Antonio Orvieto, Luigi Gresele, and Bernhard Schölkopf. Learning explanations that are hard to vary. arXiv preprint arXiv:2009.00329, 2020.   
+[80] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. openreview id=BJJsrmfCZ, 2017.   
+[81] Oskar Pfungst. Clever Hans:(the horse of Mr. Von Osten.) a contribution to experimental animal and human psychology. Holt, Rinehart and Winston, 1911.   
+[82] Tomaso Poggio, Kenji Kawaguchi, Qianli Liao, Brando Miranda, Lorenzo Rosasco, Xavier Boix, Jack Hidary, and Hrushikesh Mhaskar. Theory of deep learning iii: explaining the non-overfitting puzzle. arXiv preprint arXiv:1801.00173, 2017.   
+[83] Nasim Rahaman, Aristide Baratin, Devansh Arpit, Felix Draxler, Min Lin, Fred Hamprecht, Yoshua Bengio, and Aaron Courville. On the spectral bias of neural networks. In International Conference on Machine Learning, pages 5301–5310. PMLR, 2019.   
+[84] Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox: A python toolbox to benchmark the robustness of machine learning models. arXiv preprint arXiv:1707.04131, 2017.   
+[85] Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. " why should i trust you?" explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pages 1135–1144, 2016.   
+[86] Michael Roberts. Machine learning for covid-19 diagnosis: Promising, but still too flawed, Mar 2021.   
+[87] Basri Ronen, David Jacobs, Yoni Kasten, and Shira Kritchman. The convergence rate of neural networks for learned functions of different frequencies. In Advances in Neural Information Processing Systems, pages 4761–4771, 2019.   
+[88] Amir Rosenfeld, Richard Zemel, and John K Tsotsos. The elephant in the room. arXiv preprint arXiv:1808.03305, 2018.   
+[89] Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. arXiv preprint arXiv:1911.08731, 2019.
+
+[90] Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013.
+
+[91] Andrew M Saxe, James L McClelland, and Surya Ganguli. A mathematical theory of semantic development in deep neural networks. Proceedings of the National Academy of Sciences, 116(23):11537–11546, 2019.
+
+[92] Harshay Shah, Kaustav Tamuly, Aditi Raghunathan, Prateek Jain, and Praneeth Netrapalli. The pitfalls of simplicity bias in neural networks. arXiv preprint arXiv:2006.07710, 2020.
+
+[93] Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014.
+
+[94] Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. The Journal of Machine Learning Research, 19(1):2822–2878, 2018.
+
+[95] Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.
+
+[96] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+[97] Guillermo Valle-Pérez, Chico Q Camargo, and Ard A Louis. Deep learning generalizes because the parameter-function map is biased towards simple functions. arXiv preprint arXiv:1805.08522, 2018.
+
+[98] Vladimir Vapnik and Vlamimir Vapnik. Statistical learning theory wiley. New York, 1:624, 1998.
+
+[99] Santosh Vempala and John Wilmes. Gradient descent for one-hidden-layer neural networks: Polynomial convergence and sq lower bounds. In Conference on Learning Theory, pages 3115–3117, 2019.
+
+[100] Haohan Wang, Zexue He, Zachary C Lipton, and Eric P Xing. Learning robust representations by projecting superficial statistics out. arXiv preprint arXiv:1903.06256, 2019.
+
+[101] Sifan Wang, Xinling Yu, and Paris Perdikaris. When and why pinns fail to train: A neural tangent kernel perspective. Journal of Computational Physics, page 110768, 2021.
+
+[102] David H Wolpert. The lack of a priori distinctions between learning algorithms. Neural computation, 8(7):1341–1390, 1996.
+
+[103] Xin Xu and Eibe Frank. Logistic regression and boosting for labeled bags of instances. In Pacific-Asia conference on knowledge discovery and data mining, pages 272–281. Springer, 2004.
+
+[104] Zhi-Qin John Xu, Yaoyu Zhang, Tao Luo, Yanyang Xiao, and Zheng Ma. Frequency principle: Fourier analysis sheds light on deep neural networks. arXiv preprint arXiv:1901.06523, 2019.
+
+[105] Zhi-Qin John Xu, Yaoyu Zhang, and Yanyang Xiao. Training behavior of deep neural network in frequency domain. In International Conference on Neural Information Processing, pages 264–274. Springer, 2019.
+
+[106] Greg Yang and Hadi Salman. A fine-grained spectral perspective on neural networks. arXiv preprint arXiv:1907.10599, 2019.
+
+[107] John R Zech, Marcus A Badgeley, Manway Liu, Anthony B Costa, Joseph J Titano, and Eric K Oermann. Confounding variables can degrade generalization performance of radiological deep learning models. arXiv preprint arXiv:1807.00431, 2018.
+
+[108] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+[109] Jieyu Zhao, Tianlu Wang, Mark Yatskar, Vicente Ordonez, and Kai-Wei Chang. Men also like shopping: Reducing gender bias amplification using corpus-level constraints. arXiv preprint arXiv:1707.09457, 2017.
+
+[110] Difan Zou, Yuan Cao, Dongruo Zhou, and Quanquan Gu. Gradient descent optimizes overparameterized deep relu networks. Machine Learning, 109(3):467–492, 2020.

parse/train/hXWPpJedrVP/hXWPpJedrVP.md

@@ -0,0 +1,269 @@
+# Dataset Distillation with Infinitely Wide Convolutional Networks
+
+# Timothy Nguyen† ∗
+
+Roman Novak♠
+
+Lechao Xiao♠
+
+DeepMind† Google Research, Brain Team♠ timothycnguyen@deepmind.com {romann, xlc, jaehlee}@google.com
+
+# Abstract
+
+The effectiveness of machine learning algorithms arises from being able to extract useful features from large amounts of data. As model and dataset sizes increase, dataset distillation methods that compress large datasets into significantly smaller yet highly performant ones will become valuable in terms of training efficiency and useful feature extraction. To that end, we apply a novel distributed kernel-based meta-learning framework to achieve state-of-the-art results for dataset distillation using infinitely wide convolutional neural networks. For instance, using only 10 datapoints $0 . 0 2 \%$ of original dataset), we obtain over $65 \%$ test accuracy on CIFAR10 image classification task, a dramatic improvement over the previous best test accuracy of $40 \%$ . Our state-of-the-art results extend across many other settings for MNIST, Fashion-MNIST, CIFAR-10, CIFAR-100, and SVHN. Furthermore, we perform some preliminary analyses of our distilled datasets to shed light on how they differ from naturally occurring data.
+
+# 1 Introduction
+
+Deep learning has become extraordinarily successful in a wide variety of settings through the availability of large datasets [Krizhevsky et al., 2012, Devlin et al., 2018, Brown et al., 2020, Dosovitskiy et al., 2020]. Such large datasets enable a neural network to learn useful representations of the data that are adapted to solving tasks of interest. Unfortunately, it can be prohibitively costly to acquire such large datasets and train a neural network for the requisite amount of time.
+
+One way to mitigate this problem is by constructing smaller datasets that are nevertheless informative. Some direct approaches to this include choosing a representative subset of the dataset (i.e. a coreset) or else performing a low-dimensional projection that reduces the number of features. However, such methods typically introduce a tradeoff between performance and dataset size, since what they produce is a coarse approximation of the full dataset. By contrast, the approach of dataset distillation is to synthesize datasets that are more informative than their natural counterparts when equalizing for dataset size [Wang et al., 2018, Bohdal et al., 2020, Nguyen et al., 2021, Zhao and Bilen, 2021]. Such resulting datasets will not arise from the distribution of natural images but will nevertheless capture features useful to a neural network, a capability which remains mysterious and is far from being well-understood [Ilyas et al., 2019, Huh et al., 2016, Hermann and Lampinen, 2020].
+
+The applications of such smaller, distilled datasets are diverse. For nonparametric methods that scale poorly with the training dataset (e.g. nearest-neighbors or kernel-ridge regression), having a reduced dataset decreases the associated memory and inference costs. For the training of neural networks, such distilled datasets have found several applications in the literature, including increasing the effectiveness of replay methods in continual learning [Borsos et al., 2020] and helping to accelerate neural architecture search [Zhao et al., 2021, Zhao and Bilen, 2021].
+
+In this paper, we perform a large-scale extension of the methods of Nguyen et al. [2021] to obtain new state-of-the-art (SOTA) dataset distillation results. Specifically, we apply the algorithms KIP (Kernel Inducing Points) and LS (Label Solve), first developed in Nguyen et al. [2021], to infinitely wide convolutional networks by implementing a novel, distributed meta-learning framework that draws upon hundreds of accelerators per training. The need for such resources is necessitated by the computational costs of using infinitely wide neural networks built out of components occurring in modern image classification models: convolutional and pooling layers (see $\ S _ { \mathrm { B } }$ for details). The consequence is that we obtain distilled datasets that are effective for both kernel ridge-regression and neural network training.
+
+Additionally, we initiate a preliminary study of the images and labels which KIP learns. We provide a visual and quantitative analysis of the data learned and find some surprising results concerning their interpretability and their dimensional and spectral properties. Given the efficacy of KIP and LS learned data, we believe a better understanding of them would aid in the understanding of feature learning in neural networks.
+
+To summarize, our contributions are as follows:
+
+1. We achieve SOTA dataset distillation results on a wide variety of datasets (MNIST, FashionMNIST, SVHN, CIFAR-10, CIFAR-100) for both kernel ridge-regression and neural network training. In several instances, our results achieve an impressively wide margin over prior art, including over $2 5 \%$ and $37 \%$ absolute gain in accuracy on CIFAR-10 and SVHN image classification, respectively, when using only 10 images (Tables 1, 2, A11).   
+2. We develop a novel, distributed meta-learning framework specifically tailored to the computational burdens of sophisticated neural kernels (§2.1).   
+3. We highlight and analyze some of the peculiar features of the distilled datasets we obtain, illustrating how they differ from natural data (§4).   
+4. We open source the distilled datasets, which used thousands of GPU hours, for the research community to further investigate at https://github.com/google-research/ google-research/tree/master/kip.
+
+# 2 Setup
+
+Background on infinitely wide convolutional networks. Recent literature has established that Bayesian and gradient-descent trained neural networks converge to Gaussian Processes (GP) as the number of hidden units in intermediary layers approaches infinity (see $\ S 5$ ). These results hold for many different architectures, including convolutional networks, which converge to a particular GP in the limit of infinite channels [Novak et al., 2019, Garriga-Alonso et al., 2019, Arora et al., 2019]. Bayesian networks are described by the Neural Network Gaussian Process (NNGP) kernel, while gradient descent networks are described by the Neural Tangent Kernel (NTK). Since we are interested in synthesizing datasets that can be used with both kernel methods and common gradient-descent trained neural networks, we focus on NTK in this work.
+
+Infinitely wide networks have been shown to achieve SOTA (among non-parametric kernels) results on image classification tasks [Novak et al., 2019, Arora et al., 2019, Li et al., 2019, Shankar et al., 2020, Bietti, 2021] and even rival finite-width networks in certain settings [Arora et al., 2020, Lee et al., 2020]. This makes such kernels especially suitable for our task. As convolutional models, they encode useful inductive biases of locality and translation invariance [Novak et al., 2019], which enable good generalization. Moreover, flexible and efficient computation of these kernels are possible due to the Neural Tangent library [Novak et al., 2020].
+
+Specific models considered. The central neural network (and corresponding infinite-width model) we consider is a simple 4-layer convolutional network with average pooling layers that we refer to as ConvNet throughout the text. This architecture is a slightly modified version of the default model used by Zhao and Bilen [2021], Zhao et al. [2021] and was chosen for ease of baselining (see $\ S$ for details). In several other settings we also consider convolutional networks without pooling layers ConvVec,2 and networks with no convolutions and only fully-connected layers FC. Depth of architecture (as measured by number of hidden layers) is indicated by an integer suffix.
+
+Background on algorithms. We review the Kernel Inducing Points (KIP) and Label Solve (LS) algorithms introduced by Nguyen et al. [2021]. Given a kernel $K$ , the kernel ridge-regression (KRR) loss function trained on a support dataset $( X _ { s } , y _ { s } )$ and evaluated on a target dataset $( X _ { t } , y _ { t } )$ is
+
+$$
+L ( X _ { s } , y _ { s } ) = \frac { 1 } { 2 } \left\| y _ { t } - K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \lambda I ) ^ { - 1 } y _ { s } \right\| _ { 2 } ^ { 2 } ,
+$$
+
+where if $U$ and $V$ are sets, $K _ { U V }$ is the matrix of kernel elements $( K ( u , v ) ) _ { u \in U , v \in V }$ . Here $\lambda > 0$ is a fixed regularization parameter. The KIP algorithm consists of minimizing (1) with respect to the support set (either just the $X _ { s }$ or along with the labels $y _ { s }$ ). Here, we sample $( X _ { t } , y _ { t } )$ from a target dataset $\mathcal { D }$ at every (meta)step, and update the support set using gradient-based methods. Additional variations include augmenting the $X _ { t }$ or sampling a different kernel $K$ (from a fixed family of kernels) at each step.
+
+The Label Solve algorithm consists of solving for the least-norm minimizer of (1) with respect to $y _ { s }$ This yields the labels
+
+$$
+y _ { s } ^ { * } = \Big ( K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \lambda I ) ^ { - 1 } \Big ) ^ { + } y _ { t } ,
+$$
+
+where $A ^ { + }$ denotes the pseudo-inverse of the matrix $A$ . Note that here $( X _ { t } , y _ { t } ) = \mathcal { D }$ , i.e. the labels are solved using the whole target set.
+
+In our applications of KIP and Label Solve, the target dataset $\mathcal { D }$ is always significantly larger than the support set $( X _ { s } , y _ { s } )$ . Hence, the learned support set or solved labels can be regarded as distilled versions of their respective targets. We also initialize our support images to be a subset of natural images, though they could also be initialized randomly.
+
+Based on the infinite-width correspondence outlined above and in $\ S$ , dataset distillation using KIP or LS that is optimized for KRR should extend to the corresponding finite-width neural network training. Our experimental results in $\ S$ validate this expectation across many settings.
+
+# 2.1 Client-Server Distributed Workflow
+
+We invoke a client-server model of distributed computation3, in which a server distributes independent workloads to a large pool of client workers that share a queue for receiving and sending work. Our distributed implementation of the KIP algorithm has two distinct stages:
+
+Forward pass: In this step, we compute the support-support and target-support matrices $K ( X _ { s } , X _ { s } )$ and $K ( X _ { t } , X _ { s } )$ . To do so, we partition $X _ { s } \times X _ { s }$ and $X _ { t } \times X _ { s }$ into pairs of images $( x , x ^ { \prime } )$ , each with batch size $B$ . We send such pairs to workers compute the respective matrix block $K ( \boldsymbol { x } , \boldsymbol { x } ^ { \prime } )$ . The server aggregates all these blocks to obtain the $K ( \bar { X } _ { s } , X _ { s } )$ and $K ( X _ { t } , X _ { s } )$ matrices.
+
+Backward pass: In this step, we need to compute the gradient of the loss $L$ (1) with respect to the support set $X _ { s }$ . We need only consider $\partial L / \partial { \bar { X } } _ { s }$ since $\partial L / \partial y _ { s }$ is cheap to compute. By the chain rule, we can write
+
+$$
+\frac { \partial L } { \partial X _ { s } } = \frac { \partial L } { \partial ( K ( X _ { s } , X _ { s } ) ) } \frac { \partial K ( X _ { s } , X _ { s } ) } { \partial X _ { s } } + \frac { \partial L } { \partial ( K ( X _ { t } , X _ { s } ) ) } \frac { \partial K ( X _ { t } , X _ { s } ) } { \partial X _ { s } } .
+$$
+
+The derivatives of $L$ with respect to the kernel matrices are inexpensive, since $L$ depends in a simple way on them (matrix multiplication and inversion). What is expensive to compute is the derivative of the kernel matrices with respect to the inputs. Each kernel element is an independent function of the inputs and a naive computation of the derivative of a block would require forwardmode differentiation, infeasible due to the size of the input images and the cost to compute the individual kernel elements. Thus our main novelty is to divide up the gradient computation into backward differentiation sub-computations, specifically by using the built-in function ${ \mathrm { j a x . v j p } }$ in JAX [Bradbury et al., 2018]. Denoting $K = K \bar { ( } X _ { s } , X _ { s } )$ or $K ( X _ { t } , X _ { s } )$ for short-hand, we divide the matrix $\partial L / \partial K$ , computed on the server, into $B \times B$ blocks corresponding to $\partial L / \partial K ( x , x ^ { ' } )$ , where $x$ and $x ^ { \prime }$ each have batch size $B$ . We send each such block, along with the corresponding block of image data $( x , x ^ { \prime } )$ , to a worker. The worker then treats the $\partial L / \partial K ( x , x ^ { \prime } )$ it receives as the cotangent vector argument of ${ \mathrm { j a x . v j p } }$ that, via contraction, converts the derivative of $K ( x , x ^ { \prime } )$ with respect to $x$ into a scalar. The server aggregates all these partial gradient computations performed by the workers, over all possible $B \times B$ blocks, to compute the total gradient $\partial L / \partial X _ { s }$ used to update $X _ { s }$ .
+
+Table 1: Comparison with other methods. The left group consists of neural network based methods. The right group consists of kernel ridge-regression. All settings for KIP involve the use of label-learning. Grayscale datasets use standard channel-wise preprocessing while RGB datasets use regularized ZCA preprocessing.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Imgs/ Class</td><td rowspan="2">DC1</td><td rowspan="2">DSA1</td><td rowspan="2">KIP FC1 aug</td><td rowspan="2">LS ConvNet2,3</td><td colspan="2"> KIP ConvNet2</td></tr><tr><td>no aug</td><td>aug</td></tr><tr><td rowspan="3">MNIST</td><td>1</td><td>91.7±0.5</td><td>88.7±0.6</td><td>85.5±0.1</td><td>73.4</td><td>97.3±0.1</td><td>96.5±0.1</td></tr><tr><td>10</td><td>97.4±0.2</td><td>97.8±0.1</td><td>97.2±0.2</td><td>96.4</td><td>99.1±0.1</td><td>99.1±0.1</td></tr><tr><td>50</td><td>98.8±0.1</td><td>99.2±0.1</td><td>98.4±0.1</td><td>98.3</td><td>99.4±0.1</td><td>99.5±0.1</td></tr><tr><td rowspan="3">Fashion- MNIST</td><td>1</td><td>70.5±0.6</td><td>70.6±0.6</td><td></td><td>65.3</td><td>82.9±0.2</td><td>76.7±0.2</td></tr><tr><td>10</td><td>82.3±0.4</td><td>84.6±0.3</td><td></td><td>80.8</td><td>91.0±0.1</td><td>88.8±0.1</td></tr><tr><td>50</td><td>83.6±0.4</td><td>88.7±0.2</td><td></td><td>86.9</td><td>92.4±0.1</td><td>91.0±0.1</td></tr><tr><td rowspan="3">SVHN</td><td>1</td><td>31.2±1.4</td><td>27.5±1.4</td><td></td><td>23.9</td><td>62.4±0.2</td><td>64.3±0.4</td></tr><tr><td>10</td><td>76.1±0.6</td><td>79.2±0.5</td><td></td><td>52.8</td><td>79.3±0.1</td><td>81.1±0.5</td></tr><tr><td>50</td><td>82.3±0.3</td><td>84.4±0.4</td><td>■</td><td>76.8</td><td>82.0±0.1</td><td>84.3±0.1</td></tr><tr><td rowspan="3">CIFAR-10</td><td>1</td><td>28.3±0.5</td><td>28.8±0.7</td><td>40.5±0.4</td><td>26.1</td><td>64.7±0.2</td><td>63.4±0.1</td></tr><tr><td>10</td><td>44.9±0.5</td><td>52.1±0.5</td><td>53.1±0.5</td><td>53.6</td><td>75.6±0.2</td><td>75.5±0.1</td></tr><tr><td>50</td><td>53.9±0.5</td><td>60.6±0.5</td><td>58.6±0.4</td><td>65.9</td><td>78.2±0.2</td><td>80.6±0.1</td></tr><tr><td rowspan="2">CIFAR-100</td><td>1</td><td>12.8±0.3</td><td>13.9±0.3</td><td>-</td><td>23.8</td><td>34.9±0.1</td><td>33.3±0.3</td></tr><tr><td>10</td><td>25.2±0.3</td><td>32.3±0.3</td><td>=</td><td>39.2</td><td>47.9±0.2</td><td>49.5±0.3</td></tr></table>
+
+1 DC [Zhao et al., 2021], DSA [Zhao and Bilen, 2021], KIP FC [Nguyen et al., 2021]. 2 Ours. 3 LD [Bohdal et al., 2020] is another baseline which distills only labels using the AlexNet architecture. Our LS achieves higher test accuracy than theirs in every dataset category.
+
+# 3 Experimental Results
+
+# 3.1 Kernel Distillation Results
+
+We apply the KIP and LS algorithms using the ConvNet architecture on the datasets MNIST [LeCun et al., 2010], Fashion MNIST [Xiao et al., 2017], SVHN [Netzer et al., 2011], CIFAR-10 [Krizhevsky, 2009], and CIFAR-100. Here, the goal is to condense the train dataset down to a learned dataset of size 1, 10, or 50 images per class. We consider a variety of hyperparameter settings (image preprocessing method, whether to augment target data, and whether to train the support labels for KIP), the full details of which are described in $\ S \mathrm { A }$ . For space reasons, we show a subset of our results in Table 1, with results corresponding to the remaining set of hyperparameters left to Tables A3-A10. We highlight here that a crucial ingredient for our strong results in the RGB dataset setting is the use of regularized ZCA preprocessing. Note the variable effect that our augmentations have on performance (see the last two columns of Table 1): they typically only provides a benefit for a sufficiently large support set. This result is consistent with Zhao et al. [2021], Zhao and Bilen [2021], in which gains from augmentations are also generally obtained from larger support sets. We tried varying the fraction (0.25 and 0.5) of each target batch that is augmented at each training step and found that while 10 images still did best without augmentations, 100 and 500 images typically did slightly better with some partial augmentations (versus none or full). For instance, for 500 images on CIFAR-10, we obtained $8 1 . 1 \%$ test accuracy using augmentation rate 0.5. Thus, our observation is that given that larger support sets can distill larger target datasets, as the former increases in size, the latter can be augmented more aggressively for obtaining optimal generalization performance.
+
+![](images/148a563acf6ae0ac3256cedf7abae07a8148ed52736016b4de5e15cdee20844b.jpg)  
+Figure 1: KIP with kernel sampling vs individual kernels. Left: Evaluation of three kernels, ConvNet, Conv-Vec3, Conv-Vec8 for KRR with respect to four train settings: sampling KIP (“all”) which uses all the kernels or else KIP trained with the individual kernels. For all three kernels, “all” is a close second place, outperformed only if the kernel used for training is exactly the same as the one used for testing. Right: We take the learned images of the four train settings described above and transfer them to finite-width neural networks corresponding to ConvNet, Conv-Vec3, Conv-Vec8. Each point is a neural network trained on a specified KIP learned checkpoint. Top row is sampling KIP images and bottom row is the baseline using just ConvNet for KIP. These plots indicate that sampling KIP improves performance across the architectures that are sampled, for both MSE and cross entropy loss. Settings: CIFAR-10, 100 images, no augmentations, no ZCA, no label learning.
+
+Remarkably, our results in Table 1 outperform all prior baselines across all dataset settings. Our results are especially strong in the small support size regime, with our 1 image per class results for KRR outperforming over 100 times as many natural images (see Table A1). We also obtain a significant margin over prior art across all datasets, with our largest margin being a $37 \%$ absolute gain in test accuracy for the SVHN dataset.
+
+# 3.2 Kernel Transfer
+
+In $\ S$ , we focused on obtaining state-of-the-art dataset distillation results for image classification using a specific kernel (ConvNet). Here, we consider the variation of KIP in which we sample from a family of kernels (which we call sampling KIP). We validate that sampling KIP adds robustness to the learned images in that they perform well for the family of kernels sampled during training.
+
+In Figure 1, we plot test performance of sampling KIP when using the kernels ConvNet, Conv-Vec3, and Conv-Vec8 (denoted by “all”) alongside KIP trained with just the individual kernels. Sampling KIP performs well at test time when using any of the three kernels, whereas datasets trained using a single kernel have a significant performance drop when using a different kernel.
+
+# 3.3 Neural Network Transfer
+
+In this section, we study how our distilled datasets optimized using KIP and LS transfer to the setting of finite-width neural networks. The main results are shown in Table 2. The third column shows the best neural network performance obtained by training on a KIP dataset of the corresponding size with respect to some choice of KIP and neural network training hyperparameters (see $\ S \mathrm { A }$ for details). Since the datasets are optimized for kernel ridge-regression and not for neural network training itself, we expect some performance loss when transferring to finite-width networks, which we record in the fourth column. Remarkably, the drop due to this transfer is quite moderate or small and sometimes the transfer can even lead to gain in performance (see LS for SVHN dataset with 10 images per class).
+
+Overall, our transfer to finite-width networks outperforms prior art based on DC/DSA [Zhao et al., 2021, Zhao and Bilen, 2021] in the 1 image per class setting for all the RGB datasets (SVHN, CIFAR-10, CIFAR-100). Moreover, for CIFAR-10, we outperform DC/DSA in all settings.
+
+Table 2: Transfer of KIP and LS to neural network training. Datasets obtained from KIP and LS using the ConvNet kernel are optimized for kernel ridge-regression and thus have reduced performance when used for training the corresponding finite-width ConvNet neural network. Remarkably, the loss in performance is mostly moderate and even small in many instances. Grayscale datasets use standard channel-wise preprocessing while RGB datasets use regularized ZCA preprocessing. The KIP datasets used here can have augmentations or no augmentations and, unlike those in Table 1, can have either fixed or learned labels. $^ *$ denotes best chosen transfer is obtained with learned labels.   
+
+<table><tr><td></td><td>Imgs/Class</td><td>DC/DSA</td><td>KIP to NN</td><td>Perf. change</td><td>LS to NN</td><td>Perf. change</td></tr><tr><td rowspan="3">MNIST</td><td>1</td><td>91.7±0.5</td><td>90.1±0.1</td><td>-5.5</td><td>71.0±0.2</td><td>-2.4</td></tr><tr><td>10</td><td>97.8±0.1</td><td>97.5±0.0</td><td>-1.1</td><td>95.2±0.1</td><td>-1.2</td></tr><tr><td>50</td><td>99.2±0.1</td><td>98.3±0.1</td><td>-0.8</td><td>97.9±0.0</td><td>-0.4</td></tr><tr><td rowspan="3">Fashion-MNIST</td><td>1</td><td>70.6±0.6</td><td>73.5±0.5*</td><td>-9.8</td><td>61.2±0.1</td><td>-4.1</td></tr><tr><td>10</td><td>84.6±0.3</td><td>86.8±0.1</td><td>-1.3</td><td>79.7±0.1</td><td>-1.2</td></tr><tr><td>50</td><td>88.7±0.2</td><td>88.0±0.1*</td><td>-4.5</td><td>85.0±0.1</td><td>-1.8</td></tr><tr><td rowspan="3">SVHN</td><td>1</td><td>31.2±1.4</td><td>57.3±0.1*</td><td>-8.3</td><td>23.8±0.2</td><td>-0.2</td></tr><tr><td>10</td><td>79.2±0.5</td><td>75.0±0.1</td><td>-1.6</td><td>53.2±0.3</td><td>0.4</td></tr><tr><td>50</td><td>84.4±0.4</td><td>80.5±0.1</td><td>-1.0</td><td>76.5±0.3</td><td>-0.4</td></tr><tr><td rowspan="3">CIFAR-10</td><td>1</td><td>28.8±0.7</td><td>49.9±0.2</td><td>-9.2</td><td>24.7±0.1</td><td>-1.4</td></tr><tr><td>10</td><td>52.1±0.5</td><td>62.7±0.3</td><td>-4.6</td><td>49.3±0.1</td><td>-4.3</td></tr><tr><td>50</td><td>60.6±0.5</td><td>68.6±0.2</td><td>-4.5</td><td>62.0±0.2</td><td>-3.9</td></tr><tr><td rowspan="2">CIFAR-100</td><td>1</td><td>13.9±0.3</td><td>15.7±0.2*</td><td>-18.1</td><td>11.8±0.2</td><td>-12.0</td></tr><tr><td>10</td><td>32.3±0.3</td><td>28.3±0.1</td><td>-17.4</td><td>25.0±0.1</td><td>-14.2</td></tr></table>
+
+Figures 2 and 3 provide a closer look at KIP transfer changes under various settings. The first of these tracks how transfer performance changes when adding additional layers as function of the number of KIP training steps used. The normalization layers appear to harm performance for MSE loss, which can be anticipated from their absence in the KIP and LS optimization procedures. However they appear to provide some benefit for cross entropy loss. For Figure 3, we observe that as KIP training progresses, the downstream finite-width network’s performance also improves in general. A notable exception is observed when learning the labels in KIP, where longer training steps lead to deterioration of information useful to training finite-width neural networks. We also observe that as predicted by infinite-width theory [Jacot et al., 2018, Lee et al., 2019], the overall gap between KIP or LS performance and finite-width neural network decreases as the width increases. While our best performing transfer is obtained with width 1024, Figure 3 (middle) suggest that even with modest width of 64, our transfer can outperform prior art of $6 0 . 6 \%$ by Zhao and Bilen [2021].
+
+Finally, in Figure 4, we investigate the performance of KIP images over the course of training of a single run, as compared to natural images, over a range of hyperparameters. We find the outperformance of KIP images above natural images consistent across hyperparameters and checkpoints. This suggests that our KIP images may also be effective for accelerated hyperparameter search, an application of dataset distillation explored in Zhao et al. [2021], Zhao and Bilen [2021].
+
+Altogether, we find our neural network training results encouraging. First, it validates the applicability of infinite-width methods to the setting of finite width [Huang and Yau, 2020, Dyer and Gur-Ari, 2020, Andreassen and Dyer, 2020, Yaida, 2020, Lee et al., 2020]. Second, we find some of the transfer results quite surprising, including efficacy of label solve and the use of cross-entropy for certain settings (see $\ S$ for the full details).
+
+# 4 Understanding KIP Images and Labels
+
+A natural question to consider is what causes KIP to improve generalization performance. Does it simplify support images, removing noise and minor sources of variation while keeping only the core features shared between many target images of a given class? Or does it make them more complex by producing outputs that combine characteristics of many samples in a single resulting collage? While properly answering this question is subject to precise definitions of simplicity and complexity, we find that KIP tends to increase the complexity of pictures based on the following experiments:
+
+![](images/4b2f59db73df265ffd78c4beb7e58efaa0c701708ef3304ac1729acf17834d3d.jpg)
+
+![](images/d7101d842d66d8536c0fe0794798318cf8448c9d5fec3295db42110b30f393b0.jpg)  
+Figure 2: Robustness to neural network variations. KIP ConvNet images (trained with fixed labels) are tested on variations of the ConvNet neural network, including those which have various normalization layers (layer, instance, batch). A similar architecture to ConvNet, the Myrtle5 architecture (without normalization layers) [Shankar et al., 2020], which differs from the ConvNet architecture by having an additional convolutional layer at the bottom and a global average pooling that replaces the final local average pooling at the top, is also tested. Finally, mean-square error is compared with cross-entropy loss (left versus right). Settings: CIFAR-10, 500 images, ZCA, no label learning.
+
+![](images/d4bafe9124596e9d37dbd9d82f76504e27d351417c7bcb6711299bb95919161d.jpg)  
+Figure 3: Variations for neural network transfer. Left: Plot of transfer performance as a function of KIP training steps across various train settings. Here (a) denotes augmentations used during KIP training and $\left( \mathrm { a } { + } \mathrm { l } \right)$ denotes that additionally the labels were learned. MSE and XENT denote mean-square-error and cross entropy loss for the neural network, where for the case of XENT and $\left( \mathrm { a } \mathrm { + } \mathrm { l } \right)$ , the labels for the neural network are the argmax of the learned labels. Middle: Exploring the effect of width on transferability of vanilla KIP data. Right: The effect of width on the transferability of label solved data. Settings: CIFAR-10, 500 images, ZCA.   
+Figure 4: Hyperparameter robustness. In the above, KIP images across eight different checkpoints are used to train the ConvNet neural network. Each point in each plot is a neural network training with a different hyperparameter, and its location records the final test accuracy when training on natural images versus the KIP images obtained from initializing from such images. For both MSE and cross entropy loss, KIP images consistently exceed natural images across many hyperparameters. Settings: CIFAR-10, 500 images, ZCA, no augmentations, no label learning.
+
+![](images/e6c595174262ae29110808481345bc35e97724fca04c12c87c4596c09e29c9e0.jpg)  
+Figure 5: Examples of learned images. Images are initialized from natural images in the top row (Init) and converge to images in the bottom row (Trained). Settings: 100 images distilled, no ZCA, no label training, augmentations.
+
+• Visual analysis: qualitatively, KIP images tend to be richer in textures and contours. • Dimensional analysis: KIP produces images of higher intrinsic dimensionality (i.e. an estimate of the dimensionality of the manifold on which the images lie) than natural images. • Spectral analysis: unlike natural images, for which the bulk of generalization performance is explained by a small number of top few eigendirections, KIP images leverage the whole spectrum much more evenly.
+
+Combined, these results let us conclude that KIP usually increases complexity, integrating features from many target images into much fewer support images.
+
+Visual Analysis. A visual inspection of our learned data leads to intriguing observations in terms of interpretability. Figure 5 shows examples of KIP learned images from CIFAR-100. The resulting images are heterogeneous in terms of how they can be interpreted as distilling the data. For instance, the distilled apple image seems to consist of many apples nested within a possibly larger apple, whereas the distilled bottle image starts off as two bottles and before transforming into one, while other classes (like the beaver) are altogether visually indistinct. Investigating and quantifying aspects that make these images generalize so well is a promising avenue for future work. We show examples from other datasets in Figure A2.
+
+In Figure 6, we compare MNIST KIP data learned with and without label learning. For the latter case with images and labels optimized jointly, while labels become more informative, encoding richer inter-class information, the images become less interpretable. This behavior consistently leads to superior KRR results, but appears to not be leveraged as efficiently in the neural network transfer setting (Table 2). Experimental details can be found in $\ S \mathrm { A }$ .
+
+Dimensional Analysis. We study the intrinsic dimension of KIP images and find that they tend to grow. Intrinsic dimension (ID) was first defined by Bennett [1969] as “the number of free parameters required in a hypothetical signal generator capable of producing a close approximation to each signal in the collection”. In our context, it is the dimensionality of the manifold embedded into the image space which contains all the support images. Intuitively, simple datasets have a low ID as they can be described by a small number of coordinates on the low-dimensional data manifold.
+
+ID can be defined and estimated differently based on assumptions on the manifold structure and the probability density function of the images on this manifold (see [Camastra and Staiano, 2016] for review). We use the “Two-NN” method developed by [Facco et al., 2017], which makes relatively few assumptions and allows to estimate ID only from two nearest-neighbor distances for each datapoint.
+
+Figure 7 shows that the ID is increasing for the learned KIP images as a function of the training step across a variety of configurations (training with or without augmentations/label learning) and datasets. One might expect that a distillation procedure should decrease dimensionality. On the other hand, Ansuini et al. [2019] showed that ID increases in the earlier layers of a trained neural network. It remains to be understood if this latter observation has any relationship with our increased ID. Note that ZCA preprocessing, which played an important role for getting the best performance for our RGB datasets, increases dimensionality of the underlying data (see Figure A4).
+
+![](images/744ef5e48025d1576b73820fcc92a143cc5fbf893ece6f8a392eca2b6478b9c4.jpg)  
+Figure 6: Dataset distillation with trainable and non-trainable labels. Top row: initialization of support images and labels. Middle row: trained images if labels remain fixed. Bottom row: trained images and labels, jointly optimized. Settings: 100 images distilled, no augmentations.
+
+![](images/a06942204ec114b405c74d18fc52c11993ea495a87514472cc9da54909bdfd25.jpg)  
+Figure 7: Intrinsic dimension of a learned datasets grows during training. As training progresses, intrinsic dimension of the learned dataset grows, indicating that training non-trivially transforms the data manifold. See Figures A2 and 6 for visual examples of learned images, and Figures A3 and A4 for similar observations using other metrics and settings. Settings: 500 images distilled, no ZCA.
+
+Spectral Analysis. Another distinguishing property of KIP images is how their spectral components contribute to performance. In Figure 8, we spot how different spectral bands of KIP learned images affect test performance as compared to their initial natural images. Here, we use the FC2, Conv-Vec8, and ConvNet architectures. We note that for natural images (light bars), most of their performance is captured by the top $20 \%$ of eigenvalues. For KIP images, the performance is either more evenly distributed across the bands (FC and Conv-Vec8) or else is skewed towards the tail (ConvNet).
+
+# 5 Related Work
+
+Dataset distillation was first studied in Wang et al. [2018]. The work of Sucholutsky and Schonlau [2019], Bohdal et al. [2020] build upon it by distilling labels. Zhao et al. [2021] proposes condensing a training set by harnessing a gradient matching condition. Zhao and Bilen [2021] takes this idea further by applying a suitable augmentation strategy. Note that while Zhao and Bilen [2021] is limited in augmentation expressiveness (they have to apply a single augmentation per training iteration), we can sample augmentations independently per image in our target set per train step. Our work together with Nguyen et al. [2021] are, to the best of our knowledge, the only works using kernel-based methods for dataset distillation on image classification datasets.
+
+![](images/4c290bf4e301cc2883615e72ab385da78ab75a5398ad90dbbe6ea01579e15c20.jpg)  
+Figure 8: Spectral contribution to test accuracy shifts to the tail. By setting the ridge-parameter to zero in kernel-ridge regression and composing $K _ { X _ { s } X _ { s } } ^ { - 1 }$ with the spectral projection onto various eigenspaces, we can explore how different spectral bands affect test accuracy of kernel ridgeregression. We plot the relative change in test accuracy using contiguous bands of $20 \%$ of the eigenvalues. Settings: CIFAR-10, 500 images. Further details in $\ S$ .
+
+Our use of kernels stems from the correspondence between infinitely-wide neural networks and kernel methods [Neal, 1994, Lee et al., 2018, Matthews et al., 2018, Jacot et al., 2018, Novak et al., 2019, Garriga-Alonso et al., 2019, Arora et al., 2019, Yang, 2019a,b, Hron et al., 2020] and the extended correspondence with the finite width corrections [Dyer and Gur-Ari, 2020, Huang and Yau, 2020, Yaida, 2020]. These correspondences underlie the transferability of our KRR results to neural networks , and have been utilized in understanding trainability [Xiao et al., 2020], generalizations [Adlam and Pennington, 2020], training dynamics [Lewkowycz et al., 2020, Lewkowycz and Gur-Ari, 2020], uncertainty [Adlam et al., 2021], and demonstrated their effectiveness for smaller datasets [Arora et al., 2020] and neural architecture search [Park et al., 2020, Chen et al., 2021].
+
+# 6 Conclusion
+
+We performed an extensive study of dataset distillation using the KIP and LS algorithms applied to convolutional architectures, obtaining SOTA results on a variety of image classification datasets. In some cases, our learned datasets were more effective than a natural dataset two orders of magnitude larger in size. There are many interesting followup directions and questions from our work:
+
+First, integrating efficient kernel-approximation methods into our algorithms, such as those of Zandieh et al. [2021], will reduce computational burden and enable scaling up to larger datasets. In this direction, the understanding of how various resources (e.g. data, parameter count, compute) scale when optimizing for neural network performance has received significant attention as machine learning models continue to stretch computational limits [Hestness et al., 2017, Rosenfeld et al., 2020, Kaplan et al., 2020, Bahri et al., 2021]. Developing our understanding of how to harness smaller, yet more useful representations data would aid in such endeavors. In particular, it would be especially interesting to explore how well datasets can be compressed as they scale up in size.
+
+Second, LS and KIP with label learning shows that optimizing labels is a very powerful tool for dataset distillation. The labels we obtain are quite far away from standard, interpretable labels and we feel their effectiveness suggests that understanding of how to optimally label data warrants further study.
+
+Finally, the novel features obtained by our learned datasets, and those of dataset distillation methods in general, may reveal insights into interpretability and the nature of sample-efficient representations. For instance, observe the bee and bicycle images in Figure 5: the bee class distills into what appears to be spurious visual features (e.g. pollen), while the bicycle class distills to the essential contours of a typical bicycle. Additional analyses and explorations of this type could offer insights into the perennial question of how neural networks learn and generalize.
+
+Acknowledgments We would like to acknowledge special thanks to Samuel S. Schoenholz, who proposed and helped develop the overall strategy for our distributed KIP learning methodology. We are also grateful to Ekin Dogus Cubuk and Manuel Kroiss for helpful discussions.
+
+# References
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25:1097–1105, 2012.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.
+
+Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A Efros. Dataset distillation. arXiv preprint arXiv:1811.10959, 2018.
+
+Ondrej Bohdal, Yongxin Yang, and Timothy Hospedales. Flexible dataset distillation: Learn labels instead of images. arXiv preprint arXiv:2006.08572, 2020.
+
+Timothy Nguyen, Zhourong Chen, and Jaehoon Lee. Dataset meta-learning from kernel ridge-regression. In International Conference on Learning Representations, 2021.
+
+Bo Zhao and Hakan Bilen. Dataset condensation with differentiable siamese augmentation. In International Conference on Machine Learning, 2021.
+
+Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features, 2019.
+
+Minyoung Huh, Pulkit Agrawal, and Alexei A Efros. What makes imagenet good for transfer learning? arXiv preprint arXiv:1608.08614, 2016.
+
+Katherine L Hermann and Andrew K Lampinen. What shapes feature representations? exploring datasets, architectures, and training. arXiv preprint arXiv:2006.12433, 2020.
+
+Zalán Borsos, Mojmír Mutny, and Andreas Krause. Coresets via bilevel optimization for continual learning and \` streaming. arXiv preprint arXiv:2006.03875, 2020.
+
+Bo Zhao, Konda Reddy Mopuri, and Hakan Bilen. Dataset condensation with gradient matching. In International Conference on Learning Representations, 2021.
+
+Roman Novak, Lechao Xiao, Jaehoon Lee, Yasaman Bahri, Greg Yang, Jiri Hron, Daniel A. Abolafia, Jeffrey Pennington, and Jascha Sohl-Dickstein. Bayesian deep convolutional networks with many channels are gaussian processes. In International Conference on Learning Representations, 2019.
+
+Adrià Garriga-Alonso, Laurence Aitchison, and Carl Edward Rasmussen. Deep convolutional networks as shallow gaussian processes. In International Conference on Learning Representations, 2019.
+
+Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Russ R Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. In Advances in Neural Information Processing Systems, pages 8141–8150. Curran Associates, Inc., 2019.
+
+Zhiyuan Li, Ruosong Wang, Dingli Yu, Simon S Du, Wei Hu, Ruslan Salakhutdinov, and Sanjeev Arora. Enhanced convolutional neural tangent kernels. arXiv preprint arXiv:1911.00809, 2019.
+
+Vaishaal Shankar, Alex Chengyu Fang, Wenshuo Guo, Sara Fridovich-Keil, Ludwig Schmidt, Jonathan RaganKelley, and Benjamin Recht. Neural kernels without tangents. In International Conference on Machine Learning, 2020.
+
+Alberto Bietti. Approximation and learning with deep convolutional models: a kernel perspective. arXiv preprint arXiv:2102.10032, 2021.
+
+Sanjeev Arora, Simon S. Du, Zhiyuan Li, Ruslan Salakhutdinov, Ruosong Wang, and Dingli Yu. Harnessing the power of infinitely wide deep nets on small-data tasks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=rkl8sJBYvH.   
+Jaehoon Lee, Samuel S Schoenholz, Jeffrey Pennington, Ben Adlam, Lechao Xiao, Roman Novak, and Jascha Sohl-Dickstein. Finite versus infinite neural networks: an empirical study. In Advances in Neural Information Processing Systems, 2020.   
+Roman Novak, Lechao Xiao, Jiri Hron, Jaehoon Lee, Alexander A. Alemi, Jascha Sohl-Dickstein, and Samuel S. Schoenholz. Neural tangents: Fast and easy infinite neural networks in python. In International Conference on Learning Representations, 2020. URL https://github.com/google/neural-tangents.   
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: composable transformations of Python $^ +$ NumPy programs, 2018. URL http://github.com/google/jax.   
+Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017.   
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.   
+Arthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In Advances in Neural Information Processing Systems, 2018.   
+Jaehoon Lee, Lechao Xiao, Samuel S. Schoenholz, Yasaman Bahri, Roman Novak, Jascha Sohl-Dickstein, and Jeffrey Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. In Advances in Neural Information Processing Systems, 2019.   
+Jiaoyang Huang and Horng-Tzer Yau. Dynamics of deep neural networks and neural tangent hierarchy. In International Conference on Machine Learning, 2020.   
+Ethan Dyer and Guy Gur-Ari. Asymptotics of wide networks from feynman diagrams. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\equiv$ S1gFvANKDS.   
+Anders Andreassen and Ethan Dyer. Asymptotics of wide convolutional neural networks. arxiv preprint arXiv:2008.08675, 2020.   
+Sho Yaida. Non-Gaussian processes and neural networks at finite widths. In Mathematical and Scientific Machine Learning Conference, 2020.   
+R. Bennett. The intrinsic dimensionality of signal collections. IEEE Transactions on Information Theory, 15(5): 517–525, 1969. doi: 10.1109/TIT.1969.1054365.   
+Francesco Camastra and Antonino Staiano. Intrinsic dimension estimation: Advances and open problems. Information Sciences, 328:26–41, 2016. ISSN 0020-0255. doi: https://doi.org/10.1016/j.ins.2015.08.029. URL https://www.sciencedirect.com/science/article/pii/S0020025515006179.   
+Elena Facco, Maria d’Errico, Alex Rodriguez, and Alessandro Laio. Estimating the intrinsic dimension of datasets by a minimal neighborhood information. Scientific reports, 7(1):1–8, 2017.   
+A. Ansuini, A. Laio, J. Macke, and D. Zoccolan. Intrinsic dimension of data representations in deep neural networks. In NeurIPS, 2019.   
+Ilia Sucholutsky and Matthias Schonlau. Soft-label dataset distillation and text dataset distillation. arXiv preprint arXiv:1910.02551, 2019.   
+Radford M. Neal. Priors for infinite networks (tech. rep. no. crg-tr-94-1). University of Toronto, 1994.   
+Jaehoon Lee, Yasaman Bahri, Roman Novak, Sam Schoenholz, Jeffrey Pennington, and Jascha Sohl-dickstein. Deep neural networks as gaussian processes. In International Conference on Learning Representations, 2018.   
+Alexander G. de G. Matthews, Jiri Hron, Mark Rowland, Richard E. Turner, and Zoubin Ghahramani. Gaussian process behaviour in wide deep neural networks. In International Conference on Learning Representations, 2018.
+
+Greg Yang. Scaling limits of wide neural networks with weight sharing: Gaussian process behavior, gradient independence, and neural tangent kernel derivation. arXiv preprint arXiv:1902.04760, 2019a.
+
+Greg Yang. Wide feedforward or recurrent neural networks of any architecture are gaussian processes. In Advances in Neural Information Processing Systems, 2019b.
+
+Jiri Hron, Yasaman Bahri, Jascha Sohl-Dickstein, and Roman Novak. Infinite attention: NNGP and NTK for deep attention networks. In International Conference on Machine Learning, 2020.
+
+Lechao Xiao, Jeffrey Pennington, and Samuel S Schoenholz. Disentangling trainability and generalization in deep learning. In International Conference on Machine Learning, 2020.
+
+Ben Adlam and Jeffrey Pennington. The neural tangent kernel in high dimensions: Triple descent and a multi-scale theory of generalization. In International Conference on Machine Learning, pages 74–84. PMLR, 2020.
+
+Aitor Lewkowycz, Yasaman Bahri, Ethan Dyer, Jascha Sohl-Dickstein, and Guy Gur-Ari. The large learning rate phase of deep learning: the catapult mechanism. arXiv preprint arXiv:2003.02218, 2020.
+
+Aitor Lewkowycz and Guy Gur-Ari. On the training dynamics of deep networks with l_2 regularization. In Advances in Neural Information Processing Systems, volume 33, pages 4790–4799, 2020.
+
+Ben Adlam, Jaehoon Lee, Lechao Xiao, Jeffrey Pennington, and Jasper Snoek. Exploring the uncertainty properties of neural networks’ implicit priors in the infinite-width limit. In International Conference on Learning Representations, 2021.
+
+Daniel S Park, Jaehoon Lee, Daiyi Peng, Yuan Cao, and Jascha Sohl-Dickstein. Towards nngp-guided neural architecture search. arXiv preprint arXiv:2011.06006, 2020.
+
+Wuyang Chen, Xinyu Gong, and Zhangyang Wang. Neural architecture search on imagenet in four $\{ { \mathrm { g p u } } \}$ hours: A theoretically inspired perspective. In International Conference on Learning Representations, 2021.
+
+Amir Zandieh, Insu Han, Haim Avron, Neta Shoham, Chaewon Kim, and Jinwoo Shin. Scaling neural tangent kernels via sketching and random features. In Advances in Neural Information Processing Systems, 2021.
+
+Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory F. Diamos, Heewoo Jun, Hassan Kianinejad, Md. Mostofa Ali Patwary, Yang Yang, and Yanqi Zhou. Deep learning scaling is predictable, empirically. CoRR, abs/1712.00409, 2017. URL http://arxiv.org/abs/1712.00409.
+
+Jonathan S. Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. A constructive prediction of the generalization error across scales. In International Conference on Learning Representations, 2020.
+
+Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020.
+
+Yasaman Bahri, Ethan Dyer, Jared Kaplan, Jaehoon Lee, and Utkarsh Sharma. Explaining neural scaling laws. arXiv preprint arXiv:2102.06701, 2021.
+
+Ekin D. Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V. Le. Autoaugment: Learning augmentation strategies from data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
+
+Jascha Sohl-Dickstein, Roman Novak, Samuel S Schoenholz, and Jaehoon Lee. On the infinite width limit of neural networks with a standard parameterization. arXiv preprint arXiv:2001.07301, 2020.

parse/train/hXWPpJedrVP/hXWPpJedrVP_content_list.json

@@ -0,0 +1,1352 @@
+[
+    {
+        "type": "text",
+        "text": "Dataset Distillation with Infinitely Wide Convolutional Networks ",
+        "text_level": 1,
+        "bbox": [
+            256,
+            122,
+            740,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Timothy Nguyen† ∗ ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            220,
+            348,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Roman Novak♠ ",
+        "bbox": [
+            385,
+            219,
+            496,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lechao Xiao♠ ",
+        "bbox": [
+            542,
+            219,
+            640,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "DeepMind† Google Research, Brain Team♠ timothycnguyen@deepmind.com {romann, xlc, jaehlee}@google.com ",
+        "bbox": [
+            348,
+            246,
+            647,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            335,
+            535,
+            352
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of machine learning algorithms arises from being able to extract useful features from large amounts of data. As model and dataset sizes increase, dataset distillation methods that compress large datasets into significantly smaller yet highly performant ones will become valuable in terms of training efficiency and useful feature extraction. To that end, we apply a novel distributed kernel-based meta-learning framework to achieve state-of-the-art results for dataset distillation using infinitely wide convolutional neural networks. For instance, using only 10 datapoints $0 . 0 2 \\%$ of original dataset), we obtain over $65 \\%$ test accuracy on CIFAR10 image classification task, a dramatic improvement over the previous best test accuracy of $40 \\%$ . Our state-of-the-art results extend across many other settings for MNIST, Fashion-MNIST, CIFAR-10, CIFAR-100, and SVHN. Furthermore, we perform some preliminary analyses of our distilled datasets to shed light on how they differ from naturally occurring data. ",
+        "bbox": [
+            233,
+            366,
+            766,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            310,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has become extraordinarily successful in a wide variety of settings through the availability of large datasets [Krizhevsky et al., 2012, Devlin et al., 2018, Brown et al., 2020, Dosovitskiy et al., 2020]. Such large datasets enable a neural network to learn useful representations of the data that are adapted to solving tasks of interest. Unfortunately, it can be prohibitively costly to acquire such large datasets and train a neural network for the requisite amount of time. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            671
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One way to mitigate this problem is by constructing smaller datasets that are nevertheless informative. Some direct approaches to this include choosing a representative subset of the dataset (i.e. a coreset) or else performing a low-dimensional projection that reduces the number of features. However, such methods typically introduce a tradeoff between performance and dataset size, since what they produce is a coarse approximation of the full dataset. By contrast, the approach of dataset distillation is to synthesize datasets that are more informative than their natural counterparts when equalizing for dataset size [Wang et al., 2018, Bohdal et al., 2020, Nguyen et al., 2021, Zhao and Bilen, 2021]. Such resulting datasets will not arise from the distribution of natural images but will nevertheless capture features useful to a neural network, a capability which remains mysterious and is far from being well-understood [Ilyas et al., 2019, Huh et al., 2016, Hermann and Lampinen, 2020]. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            815
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The applications of such smaller, distilled datasets are diverse. For nonparametric methods that scale poorly with the training dataset (e.g. nearest-neighbors or kernel-ridge regression), having a reduced dataset decreases the associated memory and inference costs. For the training of neural networks, such distilled datasets have found several applications in the literature, including increasing the effectiveness of replay methods in continual learning [Borsos et al., 2020] and helping to accelerate neural architecture search [Zhao et al., 2021, Zhao and Bilen, 2021]. ",
+        "bbox": [
+            174,
+            821,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we perform a large-scale extension of the methods of Nguyen et al. [2021] to obtain new state-of-the-art (SOTA) dataset distillation results. Specifically, we apply the algorithms KIP (Kernel Inducing Points) and LS (Label Solve), first developed in Nguyen et al. [2021], to infinitely wide convolutional networks by implementing a novel, distributed meta-learning framework that draws upon hundreds of accelerators per training. The need for such resources is necessitated by the computational costs of using infinitely wide neural networks built out of components occurring in modern image classification models: convolutional and pooling layers (see $\\ S _ { \\mathrm { B } }$ for details). The consequence is that we obtain distilled datasets that are effective for both kernel ridge-regression and neural network training. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we initiate a preliminary study of the images and labels which KIP learns. We provide a visual and quantitative analysis of the data learned and find some surprising results concerning their interpretability and their dimensional and spectral properties. Given the efficacy of KIP and LS learned data, we believe a better understanding of them would aid in the understanding of feature learning in neural networks. ",
+        "bbox": [
+            176,
+            256,
+            825,
+            325
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our contributions are as follows: ",
+        "bbox": [
+            176,
+            332,
+            486,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We achieve SOTA dataset distillation results on a wide variety of datasets (MNIST, FashionMNIST, SVHN, CIFAR-10, CIFAR-100) for both kernel ridge-regression and neural network training. In several instances, our results achieve an impressively wide margin over prior art, including over $2 5 \\%$ and $37 \\%$ absolute gain in accuracy on CIFAR-10 and SVHN image classification, respectively, when using only 10 images (Tables 1, 2, A11).   \n2. We develop a novel, distributed meta-learning framework specifically tailored to the computational burdens of sophisticated neural kernels (§2.1).   \n3. We highlight and analyze some of the peculiar features of the distilled datasets we obtain, illustrating how they differ from natural data (§4).   \n4. We open source the distilled datasets, which used thousands of GPU hours, for the research community to further investigate at https://github.com/google-research/ google-research/tree/master/kip. ",
+        "bbox": [
+            210,
+            359,
+            826,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Setup",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            253,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Background on infinitely wide convolutional networks. Recent literature has established that Bayesian and gradient-descent trained neural networks converge to Gaussian Processes (GP) as the number of hidden units in intermediary layers approaches infinity (see $\\ S 5$ ). These results hold for many different architectures, including convolutional networks, which converge to a particular GP in the limit of infinite channels [Novak et al., 2019, Garriga-Alonso et al., 2019, Arora et al., 2019]. Bayesian networks are described by the Neural Network Gaussian Process (NNGP) kernel, while gradient descent networks are described by the Neural Tangent Kernel (NTK). Since we are interested in synthesizing datasets that can be used with both kernel methods and common gradient-descent trained neural networks, we focus on NTK in this work. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Infinitely wide networks have been shown to achieve SOTA (among non-parametric kernels) results on image classification tasks [Novak et al., 2019, Arora et al., 2019, Li et al., 2019, Shankar et al., 2020, Bietti, 2021] and even rival finite-width networks in certain settings [Arora et al., 2020, Lee et al., 2020]. This makes such kernels especially suitable for our task. As convolutional models, they encode useful inductive biases of locality and translation invariance [Novak et al., 2019], which enable good generalization. Moreover, flexible and efficient computation of these kernels are possible due to the Neural Tangent library [Novak et al., 2020]. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Specific models considered. The central neural network (and corresponding infinite-width model) we consider is a simple 4-layer convolutional network with average pooling layers that we refer to as ConvNet throughout the text. This architecture is a slightly modified version of the default model used by Zhao and Bilen [2021], Zhao et al. [2021] and was chosen for ease of baselining (see $\\ S$ for details). In several other settings we also consider convolutional networks without pooling layers ConvVec,2 and networks with no convolutions and only fully-connected layers FC. Depth of architecture (as measured by number of hidden layers) is indicated by an integer suffix. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Background on algorithms. We review the Kernel Inducing Points (KIP) and Label Solve (LS) algorithms introduced by Nguyen et al. [2021]. Given a kernel $K$ , the kernel ridge-regression (KRR) loss function trained on a support dataset $( X _ { s } , y _ { s } )$ and evaluated on a target dataset $( X _ { t } , y _ { t } )$ is ",
+        "bbox": [
+            173,
+            126,
+            826,
+            167
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d09c5178edafa32325041f77ec541c226a9c85f24857929893b13d7a3119d0d.jpg",
+        "text": "$$\nL ( X _ { s } , y _ { s } ) = \\frac { 1 } { 2 } \\left\\| y _ { t } - K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \\lambda I ) ^ { - 1 } y _ { s } \\right\\| _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            172,
+            673,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where if $U$ and $V$ are sets, $K _ { U V }$ is the matrix of kernel elements $( K ( u , v ) ) _ { u \\in U , v \\in V }$ . Here $\\lambda > 0$ is a fixed regularization parameter. The KIP algorithm consists of minimizing (1) with respect to the support set (either just the $X _ { s }$ or along with the labels $y _ { s }$ ). Here, we sample $( X _ { t } , y _ { t } )$ from a target dataset $\\mathcal { D }$ at every (meta)step, and update the support set using gradient-based methods. Additional variations include augmenting the $X _ { t }$ or sampling a different kernel $K$ (from a fixed family of kernels) at each step. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Label Solve algorithm consists of solving for the least-norm minimizer of (1) with respect to $y _ { s }$ This yields the labels ",
+        "bbox": [
+            173,
+            297,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6400c985b95cd910d952871747652b49009ec08e5b543a0d2f75cb6d00886af7.jpg",
+        "text": "$$\ny _ { s } ^ { * } = \\Big ( K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \\lambda I ) ^ { - 1 } \\Big ) ^ { + } y _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            332,
+            620,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $A ^ { + }$ denotes the pseudo-inverse of the matrix $A$ . Note that here $( X _ { t } , y _ { t } ) = \\mathcal { D }$ , i.e. the labels are solved using the whole target set. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our applications of KIP and Label Solve, the target dataset $\\mathcal { D }$ is always significantly larger than the support set $( X _ { s } , y _ { s } )$ . Hence, the learned support set or solved labels can be regarded as distilled versions of their respective targets. We also initialize our support images to be a subset of natural images, though they could also be initialized randomly. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Based on the infinite-width correspondence outlined above and in $\\ S$ , dataset distillation using KIP or LS that is optimized for KRR should extend to the corresponding finite-width neural network training. Our experimental results in $\\ S$ validate this expectation across many settings. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Client-Server Distributed Workflow ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            464,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We invoke a client-server model of distributed computation3, in which a server distributes independent workloads to a large pool of client workers that share a queue for receiving and sending work. Our distributed implementation of the KIP algorithm has two distinct stages: ",
+        "bbox": [
+            174,
+            546,
+            825,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Forward pass: In this step, we compute the support-support and target-support matrices $K ( X _ { s } , X _ { s } )$ and $K ( X _ { t } , X _ { s } )$ . To do so, we partition $X _ { s } \\times X _ { s }$ and $X _ { t } \\times X _ { s }$ into pairs of images $( x , x ^ { \\prime } )$ , each with batch size $B$ . We send such pairs to workers compute the respective matrix block $K ( \\boldsymbol { x } , \\boldsymbol { x } ^ { \\prime } )$ . The server aggregates all these blocks to obtain the $K ( \\bar { X } _ { s } , X _ { s } )$ and $K ( X _ { t } , X _ { s } )$ matrices. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Backward pass: In this step, we need to compute the gradient of the loss $L$ (1) with respect to the support set $X _ { s }$ . We need only consider $\\partial L / \\partial { \\bar { X } } _ { s }$ since $\\partial L / \\partial y _ { s }$ is cheap to compute. By the chain rule, we can write ",
+        "bbox": [
+            173,
+            662,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0223d220bd86139fdd8c7685f0a6f5ec74cfdd88e27573f6f19316bb7fbcc1f.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial X _ { s } } = \\frac { \\partial L } { \\partial ( K ( X _ { s } , X _ { s } ) ) } \\frac { \\partial K ( X _ { s } , X _ { s } ) } { \\partial X _ { s } } + \\frac { \\partial L } { \\partial ( K ( X _ { t } , X _ { s } ) ) } \\frac { \\partial K ( X _ { t } , X _ { s } ) } { \\partial X _ { s } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            708,
+            735,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The derivatives of $L$ with respect to the kernel matrices are inexpensive, since $L$ depends in a simple way on them (matrix multiplication and inversion). What is expensive to compute is the derivative of the kernel matrices with respect to the inputs. Each kernel element is an independent function of the inputs and a naive computation of the derivative of a block would require forwardmode differentiation, infeasible due to the size of the input images and the cost to compute the individual kernel elements. Thus our main novelty is to divide up the gradient computation into backward differentiation sub-computations, specifically by using the built-in function ${ \\mathrm { j a x . v j p } }$ in JAX [Bradbury et al., 2018]. Denoting $K = K \\bar { ( } X _ { s } , X _ { s } )$ or $K ( X _ { t } , X _ { s } )$ for short-hand, we divide the matrix $\\partial L / \\partial K$ , computed on the server, into $B \\times B$ blocks corresponding to $\\partial L / \\partial K ( x , x ^ { ' } )$ , where $x$ and $x ^ { \\prime }$ each have batch size $B$ . We send each such block, along with the corresponding block of image data $( x , x ^ { \\prime } )$ , to a worker. The worker then treats the $\\partial L / \\partial K ( x , x ^ { \\prime } )$ it receives as the cotangent vector argument of ${ \\mathrm { j a x . v j p } }$ that, via contraction, converts the derivative of $K ( x , x ^ { \\prime } )$ with respect to $x$ into a scalar. The server aggregates all these partial gradient computations performed by the workers, over all possible $B \\times B$ blocks, to compute the total gradient $\\partial L / \\partial X _ { s }$ used to update $X _ { s }$ . ",
+        "bbox": [
+            173,
+            747,
+            826,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/93a161c49cc38c7dc021cdfc3acc93e546f582a7e6e2e85d3f67088d33ea5aef.jpg",
+        "table_caption": [
+            "Table 1: Comparison with other methods. The left group consists of neural network based methods. The right group consists of kernel ridge-regression. All settings for KIP involve the use of label-learning. Grayscale datasets use standard channel-wise preprocessing while RGB datasets use regularized ZCA preprocessing. "
+        ],
+        "table_footnote": [
+            "1 DC [Zhao et al., 2021], DSA [Zhao and Bilen, 2021], KIP FC [Nguyen et al., 2021]. 2 Ours. 3 LD [Bohdal et al., 2020] is another baseline which distills only labels using the AlexNet architecture. Our LS achieves higher test accuracy than theirs in every dataset category. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Imgs/ Class</td><td rowspan=\"2\">DC1</td><td rowspan=\"2\">DSA1</td><td rowspan=\"2\">KIP FC1 aug</td><td rowspan=\"2\">LS ConvNet2,3</td><td colspan=\"2\"> KIP ConvNet2</td></tr><tr><td>no aug</td><td>aug</td></tr><tr><td rowspan=\"3\">MNIST</td><td>1</td><td>91.7±0.5</td><td>88.7±0.6</td><td>85.5±0.1</td><td>73.4</td><td>97.3±0.1</td><td>96.5±0.1</td></tr><tr><td>10</td><td>97.4±0.2</td><td>97.8±0.1</td><td>97.2±0.2</td><td>96.4</td><td>99.1±0.1</td><td>99.1±0.1</td></tr><tr><td>50</td><td>98.8±0.1</td><td>99.2±0.1</td><td>98.4±0.1</td><td>98.3</td><td>99.4±0.1</td><td>99.5±0.1</td></tr><tr><td rowspan=\"3\">Fashion- MNIST</td><td>1</td><td>70.5±0.6</td><td>70.6±0.6</td><td></td><td>65.3</td><td>82.9±0.2</td><td>76.7±0.2</td></tr><tr><td>10</td><td>82.3±0.4</td><td>84.6±0.3</td><td></td><td>80.8</td><td>91.0±0.1</td><td>88.8±0.1</td></tr><tr><td>50</td><td>83.6±0.4</td><td>88.7±0.2</td><td></td><td>86.9</td><td>92.4±0.1</td><td>91.0±0.1</td></tr><tr><td rowspan=\"3\">SVHN</td><td>1</td><td>31.2±1.4</td><td>27.5±1.4</td><td></td><td>23.9</td><td>62.4±0.2</td><td>64.3±0.4</td></tr><tr><td>10</td><td>76.1±0.6</td><td>79.2±0.5</td><td></td><td>52.8</td><td>79.3±0.1</td><td>81.1±0.5</td></tr><tr><td>50</td><td>82.3±0.3</td><td>84.4±0.4</td><td>■</td><td>76.8</td><td>82.0±0.1</td><td>84.3±0.1</td></tr><tr><td rowspan=\"3\">CIFAR-10</td><td>1</td><td>28.3±0.5</td><td>28.8±0.7</td><td>40.5±0.4</td><td>26.1</td><td>64.7±0.2</td><td>63.4±0.1</td></tr><tr><td>10</td><td>44.9±0.5</td><td>52.1±0.5</td><td>53.1±0.5</td><td>53.6</td><td>75.6±0.2</td><td>75.5±0.1</td></tr><tr><td>50</td><td>53.9±0.5</td><td>60.6±0.5</td><td>58.6±0.4</td><td>65.9</td><td>78.2±0.2</td><td>80.6±0.1</td></tr><tr><td rowspan=\"2\">CIFAR-100</td><td>1</td><td>12.8±0.3</td><td>13.9±0.3</td><td>-</td><td>23.8</td><td>34.9±0.1</td><td>33.3±0.3</td></tr><tr><td>10</td><td>25.2±0.3</td><td>32.3±0.3</td><td>=</td><td>39.2</td><td>47.9±0.2</td><td>49.5±0.3</td></tr></table>",
+        "bbox": [
+            173,
+            155,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            491,
+            825,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            385,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Kernel Distillation Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            397,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We apply the KIP and LS algorithms using the ConvNet architecture on the datasets MNIST [LeCun et al., 2010], Fashion MNIST [Xiao et al., 2017], SVHN [Netzer et al., 2011], CIFAR-10 [Krizhevsky, 2009], and CIFAR-100. Here, the goal is to condense the train dataset down to a learned dataset of size 1, 10, or 50 images per class. We consider a variety of hyperparameter settings (image preprocessing method, whether to augment target data, and whether to train the support labels for KIP), the full details of which are described in $\\ S \\mathrm { A }$ . For space reasons, we show a subset of our results in Table 1, with results corresponding to the remaining set of hyperparameters left to Tables A3-A10. We highlight here that a crucial ingredient for our strong results in the RGB dataset setting is the use of regularized ZCA preprocessing. Note the variable effect that our augmentations have on performance (see the last two columns of Table 1): they typically only provides a benefit for a sufficiently large support set. This result is consistent with Zhao et al. [2021], Zhao and Bilen [2021], in which gains from augmentations are also generally obtained from larger support sets. We tried varying the fraction (0.25 and 0.5) of each target batch that is augmented at each training step and found that while 10 images still did best without augmentations, 100 and 500 images typically did slightly better with some partial augmentations (versus none or full). For instance, for 500 images on CIFAR-10, we obtained $8 1 . 1 \\%$ test accuracy using augmentation rate 0.5. Thus, our observation is that given that larger support sets can distill larger target datasets, as the former increases in size, the latter can be augmented more aggressively for obtaining optimal generalization performance. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/148a563acf6ae0ac3256cedf7abae07a8148ed52736016b4de5e15cdee20844b.jpg",
+        "image_caption": [
+            "Figure 1: KIP with kernel sampling vs individual kernels. Left: Evaluation of three kernels, ConvNet, Conv-Vec3, Conv-Vec8 for KRR with respect to four train settings: sampling KIP (“all”) which uses all the kernels or else KIP trained with the individual kernels. For all three kernels, “all” is a close second place, outperformed only if the kernel used for training is exactly the same as the one used for testing. Right: We take the learned images of the four train settings described above and transfer them to finite-width neural networks corresponding to ConvNet, Conv-Vec3, Conv-Vec8. Each point is a neural network trained on a specified KIP learned checkpoint. Top row is sampling KIP images and bottom row is the baseline using just ConvNet for KIP. These plots indicate that sampling KIP improves performance across the architectures that are sampled, for both MSE and cross entropy loss. Settings: CIFAR-10, 100 images, no augmentations, no ZCA, no label learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            90,
+            803,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remarkably, our results in Table 1 outperform all prior baselines across all dataset settings. Our results are especially strong in the small support size regime, with our 1 image per class results for KRR outperforming over 100 times as many natural images (see Table A1). We also obtain a significant margin over prior art across all datasets, with our largest margin being a $37 \\%$ absolute gain in test accuracy for the SVHN dataset. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Kernel Transfer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            566,
+            325,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In $\\ S$ , we focused on obtaining state-of-the-art dataset distillation results for image classification using a specific kernel (ConvNet). Here, we consider the variation of KIP in which we sample from a family of kernels (which we call sampling KIP). We validate that sampling KIP adds robustness to the learned images in that they perform well for the family of kernels sampled during training. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1, we plot test performance of sampling KIP when using the kernels ConvNet, Conv-Vec3, and Conv-Vec8 (denoted by “all”) alongside KIP trained with just the individual kernels. Sampling KIP performs well at test time when using any of the three kernels, whereas datasets trained using a single kernel have a significant performance drop when using a different kernel. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Neural Network Transfer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            390,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study how our distilled datasets optimized using KIP and LS transfer to the setting of finite-width neural networks. The main results are shown in Table 2. The third column shows the best neural network performance obtained by training on a KIP dataset of the corresponding size with respect to some choice of KIP and neural network training hyperparameters (see $\\ S \\mathrm { A }$ for details). Since the datasets are optimized for kernel ridge-regression and not for neural network training itself, we expect some performance loss when transferring to finite-width networks, which we record in the fourth column. Remarkably, the drop due to this transfer is quite moderate or small and sometimes the transfer can even lead to gain in performance (see LS for SVHN dataset with 10 images per class). ",
+        "bbox": [
+            173,
+            752,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Overall, our transfer to finite-width networks outperforms prior art based on DC/DSA [Zhao et al., 2021, Zhao and Bilen, 2021] in the 1 image per class setting for all the RGB datasets (SVHN, CIFAR-10, CIFAR-100). Moreover, for CIFAR-10, we outperform DC/DSA in all settings. ",
+        "bbox": [
+            176,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a34c200cfbe088aea4d855afa6db1cfcff2d63d3f3c589cc4baa786af48c2758.jpg",
+        "table_caption": [
+            "Table 2: Transfer of KIP and LS to neural network training. Datasets obtained from KIP and LS using the ConvNet kernel are optimized for kernel ridge-regression and thus have reduced performance when used for training the corresponding finite-width ConvNet neural network. Remarkably, the loss in performance is mostly moderate and even small in many instances. Grayscale datasets use standard channel-wise preprocessing while RGB datasets use regularized ZCA preprocessing. The KIP datasets used here can have augmentations or no augmentations and, unlike those in Table 1, can have either fixed or learned labels. $^ *$ denotes best chosen transfer is obtained with learned labels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Imgs/Class</td><td>DC/DSA</td><td>KIP to NN</td><td>Perf. change</td><td>LS to NN</td><td>Perf. change</td></tr><tr><td rowspan=\"3\">MNIST</td><td>1</td><td>91.7±0.5</td><td>90.1±0.1</td><td>-5.5</td><td>71.0±0.2</td><td>-2.4</td></tr><tr><td>10</td><td>97.8±0.1</td><td>97.5±0.0</td><td>-1.1</td><td>95.2±0.1</td><td>-1.2</td></tr><tr><td>50</td><td>99.2±0.1</td><td>98.3±0.1</td><td>-0.8</td><td>97.9±0.0</td><td>-0.4</td></tr><tr><td rowspan=\"3\">Fashion-MNIST</td><td>1</td><td>70.6±0.6</td><td>73.5±0.5*</td><td>-9.8</td><td>61.2±0.1</td><td>-4.1</td></tr><tr><td>10</td><td>84.6±0.3</td><td>86.8±0.1</td><td>-1.3</td><td>79.7±0.1</td><td>-1.2</td></tr><tr><td>50</td><td>88.7±0.2</td><td>88.0±0.1*</td><td>-4.5</td><td>85.0±0.1</td><td>-1.8</td></tr><tr><td rowspan=\"3\">SVHN</td><td>1</td><td>31.2±1.4</td><td>57.3±0.1*</td><td>-8.3</td><td>23.8±0.2</td><td>-0.2</td></tr><tr><td>10</td><td>79.2±0.5</td><td>75.0±0.1</td><td>-1.6</td><td>53.2±0.3</td><td>0.4</td></tr><tr><td>50</td><td>84.4±0.4</td><td>80.5±0.1</td><td>-1.0</td><td>76.5±0.3</td><td>-0.4</td></tr><tr><td rowspan=\"3\">CIFAR-10</td><td>1</td><td>28.8±0.7</td><td>49.9±0.2</td><td>-9.2</td><td>24.7±0.1</td><td>-1.4</td></tr><tr><td>10</td><td>52.1±0.5</td><td>62.7±0.3</td><td>-4.6</td><td>49.3±0.1</td><td>-4.3</td></tr><tr><td>50</td><td>60.6±0.5</td><td>68.6±0.2</td><td>-4.5</td><td>62.0±0.2</td><td>-3.9</td></tr><tr><td rowspan=\"2\">CIFAR-100</td><td>1</td><td>13.9±0.3</td><td>15.7±0.2*</td><td>-18.1</td><td>11.8±0.2</td><td>-12.0</td></tr><tr><td>10</td><td>32.3±0.3</td><td>28.3±0.1</td><td>-17.4</td><td>25.0±0.1</td><td>-14.2</td></tr></table>",
+        "bbox": [
+            200,
+            189,
+            794,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figures 2 and 3 provide a closer look at KIP transfer changes under various settings. The first of these tracks how transfer performance changes when adding additional layers as function of the number of KIP training steps used. The normalization layers appear to harm performance for MSE loss, which can be anticipated from their absence in the KIP and LS optimization procedures. However they appear to provide some benefit for cross entropy loss. For Figure 3, we observe that as KIP training progresses, the downstream finite-width network’s performance also improves in general. A notable exception is observed when learning the labels in KIP, where longer training steps lead to deterioration of information useful to training finite-width neural networks. We also observe that as predicted by infinite-width theory [Jacot et al., 2018, Lee et al., 2019], the overall gap between KIP or LS performance and finite-width neural network decreases as the width increases. While our best performing transfer is obtained with width 1024, Figure 3 (middle) suggest that even with modest width of 64, our transfer can outperform prior art of $6 0 . 6 \\%$ by Zhao and Bilen [2021]. ",
+        "bbox": [
+            173,
+            486,
+            826,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, in Figure 4, we investigate the performance of KIP images over the course of training of a single run, as compared to natural images, over a range of hyperparameters. We find the outperformance of KIP images above natural images consistent across hyperparameters and checkpoints. This suggests that our KIP images may also be effective for accelerated hyperparameter search, an application of dataset distillation explored in Zhao et al. [2021], Zhao and Bilen [2021]. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Altogether, we find our neural network training results encouraging. First, it validates the applicability of infinite-width methods to the setting of finite width [Huang and Yau, 2020, Dyer and Gur-Ari, 2020, Andreassen and Dyer, 2020, Yaida, 2020, Lee et al., 2020]. Second, we find some of the transfer results quite surprising, including efficacy of label solve and the use of cross-entropy for certain settings (see $\\ S$ for the full details). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Understanding KIP Images and Labels ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            532,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A natural question to consider is what causes KIP to improve generalization performance. Does it simplify support images, removing noise and minor sources of variation while keeping only the core features shared between many target images of a given class? Or does it make them more complex by producing outputs that combine characteristics of many samples in a single resulting collage? While properly answering this question is subject to precise definitions of simplicity and complexity, we find that KIP tends to increase the complexity of pictures based on the following experiments: ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b2f59db73df265ffd78c4beb7e58efaa0c701708ef3304ac1729acf17834d3d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            90,
+            802,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d7101d842d66d8536c0fe0794798318cf8448c9d5fec3295db42110b30f393b0.jpg",
+        "image_caption": [
+            "Figure 2: Robustness to neural network variations. KIP ConvNet images (trained with fixed labels) are tested on variations of the ConvNet neural network, including those which have various normalization layers (layer, instance, batch). A similar architecture to ConvNet, the Myrtle5 architecture (without normalization layers) [Shankar et al., 2020], which differs from the ConvNet architecture by having an additional convolutional layer at the bottom and a global average pooling that replaces the final local average pooling at the top, is also tested. Finally, mean-square error is compared with cross-entropy loss (left versus right). Settings: CIFAR-10, 500 images, ZCA, no label learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            367,
+            803,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d4bafe9124596e9d37dbd9d82f76504e27d351417c7bcb6711299bb95919161d.jpg",
+        "image_caption": [
+            "Figure 3: Variations for neural network transfer. Left: Plot of transfer performance as a function of KIP training steps across various train settings. Here (a) denotes augmentations used during KIP training and $\\left( \\mathrm { a } { + } \\mathrm { l } \\right)$ denotes that additionally the labels were learned. MSE and XENT denote mean-square-error and cross entropy loss for the neural network, where for the case of XENT and $\\left( \\mathrm { a } \\mathrm { + } \\mathrm { l } \\right)$ , the labels for the neural network are the argmax of the learned labels. Middle: Exploring the effect of width on transferability of vanilla KIP data. Right: The effect of width on the transferability of label solved data. Settings: CIFAR-10, 500 images, ZCA. ",
+            "Figure 4: Hyperparameter robustness. In the above, KIP images across eight different checkpoints are used to train the ConvNet neural network. Each point in each plot is a neural network training with a different hyperparameter, and its location records the final test accuracy when training on natural images versus the KIP images obtained from initializing from such images. For both MSE and cross entropy loss, KIP images consistently exceed natural images across many hyperparameters. Settings: CIFAR-10, 500 images, ZCA, no augmentations, no label learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            625,
+            805,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6c595174262ae29110808481345bc35e97724fca04c12c87c4596c09e29c9e0.jpg",
+        "image_caption": [
+            "Figure 5: Examples of learned images. Images are initialized from natural images in the top row (Init) and converge to images in the bottom row (Trained). Settings: 100 images distilled, no ZCA, no label training, augmentations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            111,
+            816,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            290,
+            825,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Visual analysis: qualitatively, KIP images tend to be richer in textures and contours. • Dimensional analysis: KIP produces images of higher intrinsic dimensionality (i.e. an estimate of the dimensionality of the manifold on which the images lie) than natural images. • Spectral analysis: unlike natural images, for which the bulk of generalization performance is explained by a small number of top few eigendirections, KIP images leverage the whole spectrum much more evenly. ",
+        "bbox": [
+            218,
+            329,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Combined, these results let us conclude that KIP usually increases complexity, integrating features from many target images into much fewer support images. ",
+        "bbox": [
+            174,
+            435,
+            823,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Visual Analysis. A visual inspection of our learned data leads to intriguing observations in terms of interpretability. Figure 5 shows examples of KIP learned images from CIFAR-100. The resulting images are heterogeneous in terms of how they can be interpreted as distilling the data. For instance, the distilled apple image seems to consist of many apples nested within a possibly larger apple, whereas the distilled bottle image starts off as two bottles and before transforming into one, while other classes (like the beaver) are altogether visually indistinct. Investigating and quantifying aspects that make these images generalize so well is a promising avenue for future work. We show examples from other datasets in Figure A2. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            580
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we compare MNIST KIP data learned with and without label learning. For the latter case with images and labels optimized jointly, while labels become more informative, encoding richer inter-class information, the images become less interpretable. This behavior consistently leads to superior KRR results, but appears to not be leveraged as efficiently in the neural network transfer setting (Table 2). Experimental details can be found in $\\ S \\mathrm { A }$ . ",
+        "bbox": [
+            174,
+            587,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dimensional Analysis. We study the intrinsic dimension of KIP images and find that they tend to grow. Intrinsic dimension (ID) was first defined by Bennett [1969] as “the number of free parameters required in a hypothetical signal generator capable of producing a close approximation to each signal in the collection”. In our context, it is the dimensionality of the manifold embedded into the image space which contains all the support images. Intuitively, simple datasets have a low ID as they can be described by a small number of coordinates on the low-dimensional data manifold. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ID can be defined and estimated differently based on assumptions on the manifold structure and the probability density function of the images on this manifold (see [Camastra and Staiano, 2016] for review). We use the “Two-NN” method developed by [Facco et al., 2017], which makes relatively few assumptions and allows to estimate ID only from two nearest-neighbor distances for each datapoint. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows that the ID is increasing for the learned KIP images as a function of the training step across a variety of configurations (training with or without augmentations/label learning) and datasets. One might expect that a distillation procedure should decrease dimensionality. On the other hand, Ansuini et al. [2019] showed that ID increases in the earlier layers of a trained neural network. It remains to be understood if this latter observation has any relationship with our increased ID. Note that ZCA preprocessing, which played an important role for getting the best performance for our RGB datasets, increases dimensionality of the underlying data (see Figure A4). ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/744ef5e48025d1576b73820fcc92a143cc5fbf893ece6f8a392eca2b6478b9c4.jpg",
+        "image_caption": [
+            "Figure 6: Dataset distillation with trainable and non-trainable labels. Top row: initialization of support images and labels. Middle row: trained images if labels remain fixed. Bottom row: trained images and labels, jointly optimized. Settings: 100 images distilled, no augmentations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            85,
+            777,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a06942204ec114b405c74d18fc52c11993ea495a87514472cc9da54909bdfd25.jpg",
+        "image_caption": [
+            "Figure 7: Intrinsic dimension of a learned datasets grows during training. As training progresses, intrinsic dimension of the learned dataset grows, indicating that training non-trivially transforms the data manifold. See Figures A2 and 6 for visual examples of learned images, and Figures A3 and A4 for similar observations using other metrics and settings. Settings: 500 images distilled, no ZCA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            440,
+            776,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Spectral Analysis. Another distinguishing property of KIP images is how their spectral components contribute to performance. In Figure 8, we spot how different spectral bands of KIP learned images affect test performance as compared to their initial natural images. Here, we use the FC2, Conv-Vec8, and ConvNet architectures. We note that for natural images (light bars), most of their performance is captured by the top $20 \\%$ of eigenvalues. For KIP images, the performance is either more evenly distributed across the bands (FC and Conv-Vec8) or else is skewed towards the tail (ConvNet). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            321,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset distillation was first studied in Wang et al. [2018]. The work of Sucholutsky and Schonlau [2019], Bohdal et al. [2020] build upon it by distilling labels. Zhao et al. [2021] proposes condensing a training set by harnessing a gradient matching condition. Zhao and Bilen [2021] takes this idea further by applying a suitable augmentation strategy. Note that while Zhao and Bilen [2021] is limited in augmentation expressiveness (they have to apply a single augmentation per training iteration), we can sample augmentations independently per image in our target set per train step. Our work together with Nguyen et al. [2021] are, to the best of our knowledge, the only works using kernel-based methods for dataset distillation on image classification datasets. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c290bf4e301cc2883615e72ab385da78ab75a5398ad90dbbe6ea01579e15c20.jpg",
+        "image_caption": [
+            "Figure 8: Spectral contribution to test accuracy shifts to the tail. By setting the ridge-parameter to zero in kernel-ridge regression and composing $K _ { X _ { s } X _ { s } } ^ { - 1 }$ with the spectral projection onto various eigenspaces, we can explore how different spectral bands affect test accuracy of kernel ridgeregression. We plot the relative change in test accuracy using contiguous bands of $20 \\%$ of the eigenvalues. Settings: CIFAR-10, 500 images. Further details in $\\ S$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            93,
+            663,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our use of kernels stems from the correspondence between infinitely-wide neural networks and kernel methods [Neal, 1994, Lee et al., 2018, Matthews et al., 2018, Jacot et al., 2018, Novak et al., 2019, Garriga-Alonso et al., 2019, Arora et al., 2019, Yang, 2019a,b, Hron et al., 2020] and the extended correspondence with the finite width corrections [Dyer and Gur-Ari, 2020, Huang and Yau, 2020, Yaida, 2020]. These correspondences underlie the transferability of our KRR results to neural networks , and have been utilized in understanding trainability [Xiao et al., 2020], generalizations [Adlam and Pennington, 2020], training dynamics [Lewkowycz et al., 2020, Lewkowycz and Gur-Ari, 2020], uncertainty [Adlam et al., 2021], and demonstrated their effectiveness for smaller datasets [Arora et al., 2020] and neural architecture search [Park et al., 2020, Chen et al., 2021]. ",
+        "bbox": [
+            174,
+            410,
+            826,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            299,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We performed an extensive study of dataset distillation using the KIP and LS algorithms applied to convolutional architectures, obtaining SOTA results on a variety of image classification datasets. In some cases, our learned datasets were more effective than a natural dataset two orders of magnitude larger in size. There are many interesting followup directions and questions from our work: ",
+        "bbox": [
+            174,
+            587,
+            825,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "First, integrating efficient kernel-approximation methods into our algorithms, such as those of Zandieh et al. [2021], will reduce computational burden and enable scaling up to larger datasets. In this direction, the understanding of how various resources (e.g. data, parameter count, compute) scale when optimizing for neural network performance has received significant attention as machine learning models continue to stretch computational limits [Hestness et al., 2017, Rosenfeld et al., 2020, Kaplan et al., 2020, Bahri et al., 2021]. Developing our understanding of how to harness smaller, yet more useful representations data would aid in such endeavors. In particular, it would be especially interesting to explore how well datasets can be compressed as they scale up in size. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Second, LS and KIP with label learning shows that optimizing labels is a very powerful tool for dataset distillation. The labels we obtain are quite far away from standard, interpretable labels and we feel their effectiveness suggests that understanding of how to optimally label data warrants further study. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, the novel features obtained by our learned datasets, and those of dataset distillation methods in general, may reveal insights into interpretability and the nature of sample-efficient representations. For instance, observe the bee and bicycle images in Figure 5: the bee class distills into what appears to be spurious visual features (e.g. pollen), while the bicycle class distills to the essential contours of a typical bicycle. Additional analyses and explorations of this type could offer insights into the perennial question of how neural networks learn and generalize. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments We would like to acknowledge special thanks to Samuel S. Schoenholz, who proposed and helped develop the overall strategy for our distributed KIP learning methodology. We are also grateful to Ekin Dogus Cubuk and Manuel Kroiss for helpful discussions. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            267,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25:1097–1105, 2012. ",
+        "bbox": [
+            174,
+            175,
+            823,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            210,
+            823,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. ",
+        "bbox": [
+            173,
+            246,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A Efros. Dataset distillation. arXiv preprint arXiv:1811.10959, 2018. ",
+        "bbox": [
+            174,
+            343,
+            823,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ondrej Bohdal, Yongxin Yang, and Timothy Hospedales. Flexible dataset distillation: Learn labels instead of images. arXiv preprint arXiv:2006.08572, 2020. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy Nguyen, Zhourong Chen, and Jaehoon Lee. Dataset meta-learning from kernel ridge-regression. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            443
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Zhao and Hakan Bilen. Dataset condensation with differentiable siamese augmentation. In International Conference on Machine Learning, 2021. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features, 2019. ",
+        "bbox": [
+            176,
+            487,
+            823,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minyoung Huh, Pulkit Agrawal, and Alexei A Efros. What makes imagenet good for transfer learning? arXiv preprint arXiv:1608.08614, 2016. ",
+        "bbox": [
+            174,
+            522,
+            823,
+            550
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Katherine L Hermann and Andrew K Lampinen. What shapes feature representations? exploring datasets, architectures, and training. arXiv preprint arXiv:2006.12433, 2020. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zalán Borsos, Mojmír Mutny, and Andreas Krause. Coresets via bilevel optimization for continual learning and \\` streaming. arXiv preprint arXiv:2006.03875, 2020. ",
+        "bbox": [
+            169,
+            594,
+            823,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Zhao, Konda Reddy Mopuri, and Hakan Bilen. Dataset condensation with gradient matching. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            171,
+            631,
+            823,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roman Novak, Lechao Xiao, Jaehoon Lee, Yasaman Bahri, Greg Yang, Jiri Hron, Daniel A. Abolafia, Jeffrey Pennington, and Jascha Sohl-Dickstein. Bayesian deep convolutional networks with many channels are gaussian processes. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            666,
+            823,
+            707
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adrià Garriga-Alonso, Laurence Aitchison, and Carl Edward Rasmussen. Deep convolutional networks as shallow gaussian processes. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            171,
+            715,
+            821,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Russ R Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. In Advances in Neural Information Processing Systems, pages 8141–8150. Curran Associates, Inc., 2019. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhiyuan Li, Ruosong Wang, Dingli Yu, Simon S Du, Wei Hu, Ruslan Salakhutdinov, and Sanjeev Arora. Enhanced convolutional neural tangent kernels. arXiv preprint arXiv:1911.00809, 2019. ",
+        "bbox": [
+            173,
+            799,
+            821,
+            827
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vaishaal Shankar, Alex Chengyu Fang, Wenshuo Guo, Sara Fridovich-Keil, Ludwig Schmidt, Jonathan RaganKelley, and Benjamin Recht. Neural kernels without tangents. In International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            173,
+            837,
+            823,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alberto Bietti. Approximation and learning with deep convolutional models: a kernel perspective. arXiv preprint arXiv:2102.10032, 2021. ",
+        "bbox": [
+            171,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Simon S. Du, Zhiyuan Li, Ruslan Salakhutdinov, Ruosong Wang, and Dingli Yu. Harnessing the power of infinitely wide deep nets on small-data tasks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=rkl8sJBYvH.   \nJaehoon Lee, Samuel S Schoenholz, Jeffrey Pennington, Ben Adlam, Lechao Xiao, Roman Novak, and Jascha Sohl-Dickstein. Finite versus infinite neural networks: an empirical study. In Advances in Neural Information Processing Systems, 2020.   \nRoman Novak, Lechao Xiao, Jiri Hron, Jaehoon Lee, Alexander A. Alemi, Jascha Sohl-Dickstein, and Samuel S. Schoenholz. Neural tangents: Fast and easy infinite neural networks in python. In International Conference on Learning Representations, 2020. URL https://github.com/google/neural-tangents.   \nJames Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: composable transformations of Python $^ +$ NumPy programs, 2018. URL http://github.com/google/jax.   \nYann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   \nHan Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017.   \nYuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   \nAlex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.   \nArthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In Advances in Neural Information Processing Systems, 2018.   \nJaehoon Lee, Lechao Xiao, Samuel S. Schoenholz, Yasaman Bahri, Roman Novak, Jascha Sohl-Dickstein, and Jeffrey Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. In Advances in Neural Information Processing Systems, 2019.   \nJiaoyang Huang and Horng-Tzer Yau. Dynamics of deep neural networks and neural tangent hierarchy. In International Conference on Machine Learning, 2020.   \nEthan Dyer and Guy Gur-Ari. Asymptotics of wide networks from feynman diagrams. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\equiv$ S1gFvANKDS.   \nAnders Andreassen and Ethan Dyer. Asymptotics of wide convolutional neural networks. arxiv preprint arXiv:2008.08675, 2020.   \nSho Yaida. Non-Gaussian processes and neural networks at finite widths. In Mathematical and Scientific Machine Learning Conference, 2020.   \nR. Bennett. The intrinsic dimensionality of signal collections. IEEE Transactions on Information Theory, 15(5): 517–525, 1969. doi: 10.1109/TIT.1969.1054365.   \nFrancesco Camastra and Antonino Staiano. Intrinsic dimension estimation: Advances and open problems. Information Sciences, 328:26–41, 2016. ISSN 0020-0255. doi: https://doi.org/10.1016/j.ins.2015.08.029. URL https://www.sciencedirect.com/science/article/pii/S0020025515006179.   \nElena Facco, Maria d’Errico, Alex Rodriguez, and Alessandro Laio. Estimating the intrinsic dimension of datasets by a minimal neighborhood information. Scientific reports, 7(1):1–8, 2017.   \nA. Ansuini, A. Laio, J. Macke, and D. Zoccolan. Intrinsic dimension of data representations in deep neural networks. In NeurIPS, 2019.   \nIlia Sucholutsky and Matthias Schonlau. Soft-label dataset distillation and text dataset distillation. arXiv preprint arXiv:1910.02551, 2019.   \nRadford M. Neal. Priors for infinite networks (tech. rep. no. crg-tr-94-1). University of Toronto, 1994.   \nJaehoon Lee, Yasaman Bahri, Roman Novak, Sam Schoenholz, Jeffrey Pennington, and Jascha Sohl-dickstein. Deep neural networks as gaussian processes. In International Conference on Learning Representations, 2018.   \nAlexander G. de G. Matthews, Jiri Hron, Mark Rowland, Richard E. Turner, and Zoubin Ghahramani. Gaussian process behaviour in wide deep neural networks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            53,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Greg Yang. Scaling limits of wide neural networks with weight sharing: Gaussian process behavior, gradient independence, and neural tangent kernel derivation. arXiv preprint arXiv:1902.04760, 2019a. ",
+        "bbox": [
+            173,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Greg Yang. Wide feedforward or recurrent neural networks of any architecture are gaussian processes. In Advances in Neural Information Processing Systems, 2019b. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            154
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiri Hron, Yasaman Bahri, Jascha Sohl-Dickstein, and Roman Novak. Infinite attention: NNGP and NTK for deep attention networks. In International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            176,
+            161,
+            821,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lechao Xiao, Jeffrey Pennington, and Samuel S Schoenholz. Disentangling trainability and generalization in deep learning. In International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            174,
+            196,
+            820,
+            224
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ben Adlam and Jeffrey Pennington. The neural tangent kernel in high dimensions: Triple descent and a multi-scale theory of generalization. In International Conference on Machine Learning, pages 74–84. PMLR, 2020. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            271
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aitor Lewkowycz, Yasaman Bahri, Ethan Dyer, Jascha Sohl-Dickstein, and Guy Gur-Ari. The large learning rate phase of deep learning: the catapult mechanism. arXiv preprint arXiv:2003.02218, 2020. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aitor Lewkowycz and Guy Gur-Ari. On the training dynamics of deep networks with l_2 regularization. In Advances in Neural Information Processing Systems, volume 33, pages 4790–4799, 2020. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            343
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ben Adlam, Jaehoon Lee, Lechao Xiao, Jeffrey Pennington, and Jasper Snoek. Exploring the uncertainty properties of neural networks’ implicit priors in the infinite-width limit. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            174,
+            351,
+            821,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel S Park, Jaehoon Lee, Daiyi Peng, Yuan Cao, and Jascha Sohl-Dickstein. Towards nngp-guided neural architecture search. arXiv preprint arXiv:2011.06006, 2020. ",
+        "bbox": [
+            171,
+            398,
+            821,
+            426
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wuyang Chen, Xinyu Gong, and Zhangyang Wang. Neural architecture search on imagenet in four $\\{ { \\mathrm { g p u } } \\}$ hours: A theoretically inspired perspective. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Amir Zandieh, Insu Han, Haim Avron, Neta Shoham, Chaewon Kim, and Jinwoo Shin. Scaling neural tangent kernels via sketching and random features. In Advances in Neural Information Processing Systems, 2021. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory F. Diamos, Heewoo Jun, Hassan Kianinejad, Md. Mostofa Ali Patwary, Yang Yang, and Yanqi Zhou. Deep learning scaling is predictable, empirically. CoRR, abs/1712.00409, 2017. URL http://arxiv.org/abs/1712.00409. ",
+        "bbox": [
+            176,
+            503,
+            825,
+            544
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jonathan S. Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. A constructive prediction of the generalization error across scales. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            614
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yasaman Bahri, Ethan Dyer, Jared Kaplan, Jaehoon Lee, and Utkarsh Sharma. Explaining neural scaling laws. arXiv preprint arXiv:2102.06701, 2021. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            650
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ekin D. Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V. Le. Autoaugment: Learning augmentation strategies from data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jascha Sohl-Dickstein, Roman Novak, Samuel S Schoenholz, and Jaehoon Lee. On the infinite width limit of neural networks with a standard parameterization. arXiv preprint arXiv:2001.07301, 2020. ",
+        "bbox": [
+            171,
+            705,
+            823,
+            733
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rJgVwTVtvS/rJgVwTVtvS.md

@@ -0,0 +1,554 @@
+# Gradient Perturbation is Underrated for Differentially Private Convex Optimization
+
+Anonymous authors Paper under double-blind review
+
+# Abstract
+
+Gradient perturbation, widely used for differentially private optimization, injects noise at every iterative update to guarantee differential privacy. Previous work first determines the noise level that can satisfy the privacy requirement and then analyzes the utility of noisy gradient updates as in non-private case. In this paper, we explore how the privacy noise affects the optimization property. We show that for differentially private convex optimization, the utility guarantee of both DP-GD and DP-SGD is determined by an expected curvature rather than the minimum curvature. The expected curvature represents the average curvature over the optimization path, which is usually much larger than the minimum curvature and hence can help us achieve a significantly improved utility guarantee. By using the expected curvature, our theory justifies the advantage of gradient perturbation over other perturbation methods and closes the gap between theory and practice. Extensive experiments on real world datasets corroborate our theoretical findings.
+
+# 1 Introduction
+
+Machine learning has become a powerful tool for many practical applications. The training process often needs access to some private dataset, e.g., applications in financial and medical fields. Recent work has shown that the model learned from training data may leak unintended information of individual records (Fredrikson et al., 2015; Wu et al., 2016; Shokri et al., 2017; Hitaj et al., 2017). It is known that Differential privacy (DP) (Dwork et al., 2006a;b) is a golden standard for privacy preserving data analysis. It provides provable privacy guarantee by ensuring the influence of any individual record is negligible. It has been deployed into real world applications by large-scale corporations and U.S. Census Bureau (Erlingsson et al., 2014; McMillan, 2016; Abowd, 2016; Ding et al., 2017).
+
+We study the fundamental problem when differential privacy meets machine learning: the differentially private empirical risk minimization (DP-ERM) problem (Chaudhuri & Monteleoni, 2009; Chaudhuri et al., 2011; Kifer et al., 2012; Bassily et al., 2014; Talwar et al., 2015; Wu et al., 2017; Zhang et al., 2017; Wang et al., 2017; Smith et al., 2017; Jayaraman et al., 2018; Feldman et al., 2018; Iyengar et al., 2019; Wang & Gu, 2019). DP-ERM minimizes the empirical risk while guaranteeing that the output of learning algorithm is differentially private with respect to the training data. Such privacy guarantee provides strong protection against potential adversaries (Hitaj et al., 2017; Rahman et al., 2018). In order to guarantee privacy, it is necessary to introduce randomness to the algorithm. There are usually three ways to introduce randomness according to the time of adding noise: output perturbation, objective perturbation and gradient perturbation.
+
+Output perturbation (Wu et al., 2017; Zhang et al., 2017) first runs the learning algorithm the same as in the non-private case then adds noise to the output parameter. Objective perturbation (Chaudhuri et al., 2011; Kifer et al., 2012; Iyengar et al., 2019) perturbs the objective (i.e., the empirical loss) then release the minimizer of the perturbed objective. Gradient perturbation (Song et al., 2013; Bassily et al., 2014; Abadi et al., 2016; Wang et al., 2017; Lee & Kifer, 2018; Jayaraman et al., 2018) perturbs each intermediate update. If each update is differentially private, the composition theorem of differential privacy ensures the whole learning procedure is differentially private.
+
+Gradient perturbation comes with several advantages over output/objective perturbations. Firstly, gradient perturbation does not require strong assumption on the objective because it only needs to bound the sensitivity of gradient update rather than the whole learning process. Secondly, gradient perturbation can release the noisy gradient at each iteration without damaging the privacy guarantee as differential privacy is immune to post processing (Dwork et al., 2014). Thus, it is a more favorable choice for certain applications such as distributed optimization (Rajkumar & Agarwal, 2012; Agarwal et al., 2018; Jayaraman et al., 2018). At last, gradient perturbation often achieves better empirical utility than output/objective perturbations for DP-ERM.
+
+However, the existing theoretical utility guarantee for gradient perturbation is the same as or strictly inferior to that of other perturbation methods as shown in Table 1. This motivates us to ask
+
+“What is wrong with the theory for gradient perturbation? Can we justify the empirical advantage of gradient perturbation theoretically?”
+
+We revisit the analysis for gradient perturbation approach. Previous work (Bassily et al., 2014; Wang et al., 2017; Jayaraman et al., 2018) derive the utility guarantee of gradient perturbation via two steps. They first determine the noise variance at each step that meets the privacy requirement and then derive the utility guarantee by using the convergence analysis the same as in non-private case. However, the noise to guarantee privacy naturally affects the optimization procedure, but previous approach does not exploit the interaction between privacy noise and optimization of gradient perturbation.
+
+In this paper, we utilize the fact the privacy noise affects the optimization procedure and establish new and much tighter utility guarantees for gradient perturbation approaches. Our contribution can be summarized as follows.
+
+• We introduce an expected curvature that can characterize the optimization property accurately when there is perturbation noise at each gradient update. • We establish the utility guarantees for DP-GD for both convex and strongly convex objectives based on the expected curvature rather than the usual minimum curvature. • We also establish the the utility guarantees for DP-SGD for both convex and strongly convex objectives based on the expected curvature. To the best of our knowledge, this is the first work to remove the dependency on minimum curvature for DP-ERM algorithms.
+
+In DP-ERM literature, there is a gap between the utility guarantee of non-strongly convex objectives and that of strongly convex objectives. However, by using the expected curvature, we show that some of the non-strongly convex objectives can achieve the same order of utility guarantee as the strongly convex objectives, matching the empirical observation. This is because the expected curvature could be relatively large even for non-strongly convex objectives.
+
+As we mentioned earlier, prior to our work, there is a mismatch between theoretical guarantee and empirical observation of gradient perturbation approach compared with other two perturbation approaches. Our result theoretically justifies the advantage of gradient perturbation and close the mismatch.
+
+# 1.1 Paper Organization
+
+The rest of this paper is organized as follows. Section 2 introduces notations and the DP-ERM task. In Sections 3, we first introduce the expected curvature and establish the utility guarantee of both DP-GD and DP-SGD based on such expected curvature. Then we give some discussion on three perturbation approaches. We conduct extensive experiments in Section 4. Finally, we conclude in Section 5.
+
+Table 1: Expected excess empirical risk bounds under $( \epsilon , \delta )$ -DP, where $n$ and $p$ are the number of samples and the number of parameters, respectively, and $\beta , \mu$ and $\nu$ are the smooth coefficient, the strongly convex coefficient and the expected curvature, respectively, and $\nu \geq \mu$ (see Section 3.1). We note that $\mu = 0$ denotes the convex but not strongly convex objective. The Lipschitz constant $L$ is assumed to be 1. We omit $\log \left( 1 / \delta \right)$ for simplicity.   
+
+<table><tr><td rowspan=1 colspan=1>Authors</td><td rowspan=1 colspan=1>Perturbation</td><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Utility (μ = 0)</td><td rowspan=1 colspan=3>Utility(u&gt;0）</td></tr><tr><td rowspan=1 colspan=1>Chaudhuri et al. (2011)</td><td rowspan=1 colspan=1>Objective</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=2>0   pun22</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Zhang et al. (2017)</td><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=1>GD</td><td rowspan=1 colspan=1>0 ()2/3)ne</td><td rowspan=1 colspan=2>0   βpHn2c²</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Bassily et al. (2014)</td><td rowspan=1 colspan=1>Gradient</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>0Vplog3/2（n）ne</td><td rowspan=1 colspan=3>0plog²（n）μn2c²</td></tr><tr><td rowspan=1 colspan=1>Jayaraman et al. (2018)</td><td rowspan=1 colspan=1>Gradient</td><td rowspan=1 colspan=1>GD</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=3>0βplog²(n）μ²n2e2</td></tr><tr><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Gradient</td><td rowspan=1 colspan=1>GD</td><td rowspan=1 colspan=1>0 V&gt;Bplog(n)v²n2e²nE</td><td rowspan=1 colspan=3>0βplog(n)v²n2c2</td></tr><tr><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Gradient</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>0Vplog(n）&gt;plog(n）nevn2e2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>plog(n）vn2e2</td><td rowspan=1 colspan=1></td></tr></table>
+
+# 2 Preliminary
+
+We introduce notations and definitions in this section. Given dataset $D = \{ d _ { 1 } , \ldots , d _ { n } \}$ , the objective function $F ( { \pmb x } ; D )$ is defined as $\begin{array} { r } { F ( \pmb { x } ; D ) \triangleq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } f ( \pmb { x } ; d _ { i } ) } \end{array}$ , where $f ( \pmb { x } ; d _ { i } ) : \mathbb { R } ^ { p }  \mathbb { R }$ is the loss of model $\pmb { x } \in \mathbb { R } ^ { p }$ for the record $d _ { i }$ .
+
+For simplicity, we use $F ( { \pmb x } )$ to denote $F ( { \pmb x } ; D )$ . We use $\lVert \boldsymbol { v } \rVert$ to denote the $l _ { 2 }$ norm of a vector $_ { v }$ . We use $\begin{array} { r } { \mathcal { X } _ { f } ^ { * } = \arg \operatorname* { m i n } _ { { \pmb x } \in \mathbb { R } ^ { p } } f ( { \pmb x } ) } \end{array}$ to denote the set of optimal solutions of $f ( { \pmb x } )$ . Throughout this paper, we assume $\mathcal { X } _ { f } ^ { \ast }$ non-empty.
+
+Definition 1 (Objective properties). For any $\ b { x } , \ b { y } \in \mathbb { R } ^ { p }$ , $a$ function $f : \mathbb { R } ^ { p }  \mathbb { R }$
+
+• is $L$ -Lipschitz if $| f ( \pmb { x } ) - f ( \pmb { y } ) | \leq L \| \pmb { x } - \pmb { y } \|$ .   
+• is $\beta$ -smooth if $\begin{array} { r } { f ( \pmb { y } ) \leq f ( \pmb { x } ) + \langle \nabla f ( \pmb { x } ) , \pmb { y } - \pmb { x } \rangle + \frac { \beta } { 2 } \left. \pmb { y } - \pmb { x } \right. ^ { 2 } . } \end{array}$   
+• is convex if $\langle \nabla f ( { \pmb x } ) - \nabla f ( { \pmb y } ) , { \pmb x } - { \pmb y } \rangle \geq 0$ .   
+• is $\mu$ -strongly convex (or $\mu$ -SC) if $\left. \nabla f ( { \pmb x } ) - \nabla f ( { \pmb y } ) , { \pmb x } - { \pmb y } \right. \geq \mu \left. { \pmb x } - { \pmb y } \right. ^ { 2 } .$
+
+The strong convexity coefficient $\mu$ is the lower bound of the minimum curvature of function $f$ over the domain.
+
+We say that two datasets $D , D ^ { \prime }$ are neighboring datasets (denoted as $D \sim D ^ { ' }$ ) if $D$ can be obtained by arbitrarily modifying one record in $D ^ { \prime }$ (or vice versa). In this paper we consider $( \epsilon , \delta )$ -differential privacy as follows.
+
+Definition 2 ( $( \epsilon , \delta )$ -DP (Dwork et al., 2006a;b)). A randomized mechanism $\mathcal { M } : D  \mathcal { R }$ guarantees $( \epsilon , \delta )$ -differential privacy if for any two neighboring input datasets $D , D ^ { ' }$ and for any subset of outputs $S \subseteq { \mathcal { R } }$ it holds that $P r [ \mathcal { M } ( D ) \in S ] \leq e ^ { \epsilon } P r [ \mathcal { M } ( D ^ { ' } ) \in S ] + \delta$ .
+
+We note that $\delta$ can be viewed as the probability that original $\epsilon$ -DP fails and a meaningful setting requires $\begin{array} { r } { \delta \ll \frac { 1 } { n } } \end{array}$ . By its definition, differential privacy controls the maximum influence that any individual record can produce. Smaller $\epsilon , \delta$ implies less information leak but usually leads to worse utility. One can adjust $\epsilon , \delta$ to trade off between privacy and utility.
+
+DP-ERM requires the output $\pmb { x } _ { o u t } \in \mathbb { R } ^ { p }$ is differentially private with respect to the input dataset $D$ . Let ${ \pmb x } _ { * } \in \mathcal { X } _ { F } ^ { * }$ be one of the optimal solutions of $F ( { \pmb x } )$ , the utility of DP-ERM algorithm is measured by expected excess empirical risk : $\mathbb { E } [ F ( { \pmb x } _ { o u t } ) - F ( { \pmb x } _ { * } ) ]$ , where the expectation is taken over the algorithm randomness.
+
+# 3 Main Results
+
+In this section, we first define the expected curvature $\nu$ and explain why it depends only on the average curvature. We then use such expected curvature to improve the analysis of both DP-SGD and DP-GD.
+
+# 3.1 Expected Curvature
+
+In non-private setting, the analysis of convex optimization relies on the strongly convex coefficient $\mu$ , which is the minimum curvature over the domain and can be extremely small for some common objectives. Previous work on DP-ERM uses the same analysis as in non-private case and therefore the resulting utility bounds rely on the minimum curvature. In our analysis, however, we avoid the dependency on the minimum curvature by exploiting how the privacy noise affects the optimization. With the perturbation noise, the expected curvature that the optimization path encounters is related to the average curvature instead of the minimum curvature. Definition 3 uses $\nu$ to capture such average curvature with Gaussian noise. We use $\begin{array} { r } { \pmb { x } _ { * } = \arg \operatorname* { m i n } _ { \pmb { x } \in \mathcal { X } _ { * } } \| \pmb { x } - \pmb { x } _ { 1 } \| } \end{array}$ to denote the closest solution to the initial point.
+
+Definition 3 (Expected curvature). A convex function $F : \mathbb { R } ^ { p } \to \mathbb { R }$ , has expected curvature $\nu$ with respect to noise $\mathcal { N } ( 0 , \sigma ^ { 2 } I _ { p } )$ if for any $\pmb { x } \in \mathbb { R } ^ { p }$ and ${ \tilde { \pmb { x } } } = { \pmb { x } } - { \boldsymbol { z } }$ where $z \sim { \mathcal { N } } ( 0 , \sigma ^ { 2 } I _ { p } )$ it holds that
+
+$$
+\mathbb { E } [ \langle \nabla F ( \tilde { \pmb { x } } ) , \tilde { \pmb { x } } - \pmb { x } _ { * } \rangle ] \geq \nu \mathbb { E } [ \| \tilde { \pmb { x } } - \pmb { x } _ { * } \| ^ { 2 } ] ,
+$$
+
+where the expectation is taken with respect to $_ { z }$
+
+Claim 1. If $F ^ { \prime }$ is $\mu$ -strongly convex, we have $\nu \geq \mu$
+
+Proof. It can be verified that $\nu = \mu$ always holds because of the strongly convex definition.
+
+In fact, $\nu$ represents the average curvature and is much larger than $\mu$ . We use $\mathbf { x } ^ { \prime }$ to denote the transpose of $_ { x }$ . Let $H _ { x } = \nabla ^ { 2 } F ( { \pmb x } )$ be the Hessian matrix evaluated at $_ { x }$ . We use Taylor expansion to approximate the left hand side of Eq (1) as follows
+
+$$
+\begin{array} { r } { \mathbb { E } [ \langle \nabla F ( \tilde { \pmb { x } } ) , \tilde { \pmb { x } } - \pmb { x } _ { * } \rangle ] \approx \mathbb { E } [ \langle \nabla F ( \pmb { x } ) - \pmb { H } _ { \pmb { x } } \pmb { z } , \pmb { x } - \pmb { z } - \pmb { x } _ { * } \rangle ] } \\ { = \langle \nabla F ( \pmb { x } ) , \pmb { x } - \pmb { x } _ { * } \rangle + \mathbb { E } [ \pmb { z } ^ { \prime } H _ { \pmb { x } } \pmb { z } ] } \\ { = \langle \nabla F ( \pmb { x } ) , \pmb { x } - \pmb { x } _ { * } \rangle + \sigma ^ { 2 } \operatorname { t r } ( H _ { \pmb { x } } ) . } \end{array}
+$$
+
+For convex objective, the Hessian matrix is positive semi-definite and $\mathrm { t r } ( H _ { \pmb { x } } )$ is the sum of the eigenvalues of $H _ { x }$ . We can further express out the right hand side of Eq (1) as follows
+
+$$
+\begin{array} { r } { \mathbb { E } [ \| \tilde { \pmb { x } } - \pmb { x } _ { * } \| ^ { 2 } ] = \mathbb { E } [ \| \pmb { x } - \pmb { z } - \pmb { x } _ { * } \| ^ { 2 } ] = \nu \left( \| \pmb { x } - \pmb { x } _ { * } \| ^ { 2 } + p \sigma ^ { 2 } \right) . } \end{array}
+$$
+
+Based on the above approximation, we can estimate the value of $\nu$ in Definition 3: $\nu \lesssim$ $\frac { \mathop { \mathrm { t r } } ( H _ { \pmb { x } } ) \sigma ^ { 2 } + \mu \| \pmb { x } - \pmb { x } _ { * } \| ^ { 2 } } { p \sigma ^ { 2 } + \| \pmb { x } - \pmb { x } _ { * } \| ^ { 2 } }$ . For relatively large $\sigma ^ { 2 }$ , this implies $\begin{array} { r } { \nu \approx \frac { \mathrm { t r } ( H _ { x } ) } { p } } \end{array}$ tr(Hx) that is the average curvature at $_ { x }$ . Large variance is a reasonable setting because meaningful differential privacy guarantee requires non-trivial amount of noise.
+
+The above analysis suggests that $\nu$ can be independent of and much larger than $\mu$ . This is indeed true for many convex objectives. Let us take the $l _ { 2 }$ regularized logistic regression as an example. The objective is strongly convex only due to the $l _ { 2 }$ regularizer. Thus, the minimum curvature (strongly convex coefficient) is the regularization coefficient $\lambda$ . Sharmir et al. [1] shows the optimal choice of $\lambda$ is $\Theta ( n ^ { - 1 / 2 } )$ (Section 4.3 in [1]). In practice, typical choice of $\lambda$ is even smaller and could be on the order of $n ^ { - 1 }$ . Figure 1 compares the minimum and average curvatures of regularized logistic regression during the training process. The average curvature is basically unaffected by the regularization term $\lambda$ . In contrast, the minimum curvature reaches $\lambda$ in first few steps. Therefore removing the dependence on minimum curvature is a significant improvement. We also plot the curvatures for another dataset KDDCup99 in the Appendix C. The resulting curvatures are similar to Figure 1.
+
+Perturbation noise is necessary to attain $\nu > \mu$ . We note that $\nu = \mu$ when the training process does not involve perturbation noise (corresponding to $\sigma = 0$ in Definition 3). For example, objective/output perturbation cannot utilize this expected curvature condition as no noise is injected in their training process. Therefore, among three existing perturbation methods, gradient perturbation is the only method can leverage such effect of noise.
+
+![](images/ae96e95a757d3581547102e379e153c5a8968b1bb295cc45f696ce4cc9d3ee9b.jpg)  
+Figure 1: Curvatures of regularized logistic regression on Adult dataset over training. Dot/cross symbol represents average/minimum curvature respectively.
+
+![](images/6923d3dc5e0e5aeb483be0ad716b1f4b6fae1ccf325f6cb09ef192bbd44423a7.jpg)  
+Figure 2: Illustration of a generic loss function in the high dimensional setting ( $p { > } n$ , Figure 3 in Negahban et al. (2012)).
+
+We note that $\mu = 0$ does not necessarily lead to $\nu = 0$ . A concrete example is given in Figure 2 (from Negahban et al. (2012)). It provides an illustration of the loss function in the high-dimensional $( p > n )$ setting, i.e., the resticted strongly convex scenario: the loss is curved in certain directions but completely flat in others. The average curvature of such objective is always positive but the worst curvature is 0. Though some recent work shows the utility guarantee of high dimensional DP-ERM task may not depend on the worst curvature (Wang & Gu, 2019), Figure 2 still provides a good illustration for the case of $\nu > \mu = 0$ Moreover, as shown in Figure 1, the average curvature of logistic regression on Adult dataset is above 0 during the training procedure even the regularization term is 0. As we will show later, a positive $\nu$ over the optimization path is sufficient for our optimization analysis.
+
+# 3.2 Utility Guarantee of DP-GD Based on Expected Curvature
+
+In this section we show that the expected curvature can be used to improve the utility bound of DP-GD (Algorithm 1).
+
+<table><tr><td>Algorithm 1: Differentially Private Gradient Descent (DP-GD)</td></tr><tr><td>Input: Privacy parameters e,δ; running steps T; learning rate n. Loss function F(x) with Lipschitz constant L.</td></tr><tr><td>for t=1 to T do</td></tr><tr><td>Compute gt = VF(xt).</td></tr><tr><td>Update parameter Xt+1 = xt - Nt (gt + zt), where zt ~ N(0,σ²Ip). end for</td></tr></table>
+
+Algorithm 1 is $( \epsilon , \delta )$ -DP if we set $\begin{array} { r } { \sigma _ { t } = \Theta \left( \frac { L \sqrt { T \log ( 1 / \delta ) } } { n \epsilon } \right) } \end{array}$ (Jayaraman et al., 2018). Let $\pmb { x } _ { 1 } , \ldots , \pmb { x } _ { T }$ be the training path and $\nu = \operatorname* { m i n } \{ \nu _ { 1 } , \dots , \nu _ { T } \}$ be the minimum expected curvature over the path. Now we present the utility guarantee of DP-GD for the case of $\nu > 0$ .
+
+Theorem 1 (Utility guarantee, $\nu > 0$ .). Suppose $F ^ { \prime }$ is $L$ -Lipschitz and $\beta$ -smooth with $\nu$ expected curvature. Set $\begin{array} { r } { \eta \le { \frac { 1 } { \beta } } } \end{array}$ , $\begin{array} { r } { T = \frac { 2 \log ( n ) } { \eta \nu } } \end{array}$ and $\sigma _ { t } = \Theta \left( L \sqrt { T \log ( 1 / \delta ) } / n \epsilon \right)$ , we have
+
+$$
+\mathbb { E } \left[ F \left( \pmb { x } _ { T + 1 } \right) - F \left( \pmb { x } _ { \ast } \right) \right] = \mathcal { O } \left( \frac { \beta p \log { \left( n \right) L ^ { 2 } } \log { \left( 1 / \delta \right) } } { \nu ^ { 2 } n ^ { 2 } \epsilon ^ { 2 } } \right) .
+$$
+
+Proof. All proofs in this paper are relegated to Appendix A.
+
+Remark 1. Theorem 3 only depends on the expected curvature over the training path $\nu$ .
+
+The expectation is taken over the algorithm randomness if without specification. Theorem 1 significantly improves the original analysis of DP-GD because of our arguments in Section 3.1. If $\nu = 0$ , then the curvatures are flatten in all directions. One example is the linear function, which is used by Bassily et al. (2014) to derive their utility lower bound. Such simple function may not be commonly used as loss function in practice. Nonetheless, we give the utility guarantee for the case of $\nu = 0$ in Theorem 2.
+
+Theorem 2 (Utility guarantee, $\nu = 0$ .). Suppose $F$ is $L$ -Lipschitz and $\beta$ -smooth. Set $\begin{array} { r } { \eta = \frac { 1 } { \beta } } \end{array}$ , T = nβ√ and $\sigma _ { t } = \Theta \left( L \sqrt { T \log ( 1 / \delta ) } / n \epsilon \right)$ . Let $\begin{array} { r } { \bar { \pmb x } = \frac { 1 } { T } \sum _ { i = 1 } ^ { T } \pmb x _ { i + 1 } } \end{array}$ , we have
+
+$$
+\mathbb { E } [ F \left( \bar { \pmb { x } } \right) - F \left( \pmb { x } _ { \ast } \right) ] = \mathcal { O } \left( \frac { \sqrt { p } L ^ { 2 } \log \left( 1 / \delta \right) } { n \epsilon } \right) .
+$$
+
+We use parameter averaging to reduce the influence of perturbation noise because gradient update does not have strong contraction effect when $\nu = 0$ .
+
+# 3.3 Utiltiy Guarantee of DP-SGD Based on Expected Curvature
+
+Stochastic gradient descent has become one of the most popular optimization methods because of the cheap one-iteration cost. In this section we show that expected curvature can also improve the utility analysis for DP-SGD (Algorithm 2). We note that $\nabla f ( { \pmb x } )$ represents an element from the subgradient set evaluated at $_ { x }$ when the objective is not smooth. Before stating our theorem, we introduce the moments accountant technique (Lemma 1) that is essential to establish privacy guarantee.
+
+Lemma 1 (Abadi et al. (2016)). There exist constants $c _ { 1 }$ and $c _ { 2 }$ so that given running steps $T$ , for any √ $\epsilon < c _ { 1 } T / n ^ { 2 }$ , Algorithm $\mathcal { Q }$ is $( \epsilon , \delta )$ -differentially private for any $\delta > 0$ if we choose $\sigma \ge c _ { 2 } \frac { \sqrt { T l o g ( 1 / \delta ) } } { n \epsilon }$
+
+# Algorithm 2: Differentially Private Stochastic Gradient Descent (DP-SGD)
+
+Input : Dataset $D = \{ d _ { 1 } , \ldots , d _ { n } \}$ . Individual loss function: $f _ { i } \left( \pmb { x } \right) = f \left( \pmb { x } ; d _ { i } \right)$ with Lipschitz constant $L$ . Number of iterations: $T$ . Learning rate: $\eta _ { t }$ .
+
+1 for $t = 1$ to $T$ do
+
+Sample $i _ { t }$ from $[ n ]$ uniformly.   
+Compute ${ \pmb g } _ { t } = \nabla f _ { i _ { t } } \left( { \pmb x } _ { t } \right)$ .   
+Update parameter ${ \pmb x } _ { t + 1 } = { \pmb x } _ { t } - \eta _ { t } \left( { \pmb g } _ { t } + { \pmb z } _ { t } \right)$ , where $z _ { t } \sim \mathcal { N } \left( 0 , L ^ { 2 } \sigma ^ { 2 } I _ { p } \right)$ .
+
+5 end
+
+For the case of $\nu > 0$ , Theorem 3 presents the utility guarantee of DP-SGD.
+
+Theorem 3 (Utility guarantee, $\nu > 0$ .). Suppose $F$ is $L$ -Lipschitz with $\nu$ expected curvature. Choose $\sigma$ based on Lemma $\mathit { 1 }$ to guarantee $( \epsilon , \delta )$ -DP. Set $\begin{array} { r } { \eta _ { t } = \frac { 1 } { \nu t } } \end{array}$ and $T = n ^ { 2 } \epsilon ^ { 2 }$ , we have
+
+$$
+\mathbb { E } [ F \left( \pmb { x } _ { T } \right) - F \left( \pmb { x } _ { \ast } \right) ] = \mathcal { O } \left( \frac { p L ^ { 2 } \log \left( n \right) \log \left( 1 / \delta \right) } { n ^ { 2 } \epsilon ^ { 2 } \nu } \right) .
+$$
+
+Remark 2. Theorem 3 does not require smooth assumption.
+
+Theorem 3 shows the utility guarantee of DP-SGD also depends on $\nu$ rather than $\mu$ . We set $T = \Theta ( n ^ { 2 } )$ following Bassily et al. (2014). We note that $T = \Theta ( n ^ { 2 } )$ is necessary even for non-private SGD to reach $1 / n ^ { 2 }$ precision. We next show for a relatively coarse precision, the running time can be reduced significantly.
+
+Theorem 4. SupposeLemma 1 to guarantee $F ^ { \prime }$ s- $L$ Lipsc. Set th a $\nu$ curvatur. Suppose oose , we $\sigma$ based onave $( \epsilon , \delta )$ $D P$ $\begin{array} { r } { \eta _ { t } = \frac { 1 } { \nu t } } \end{array}$ $\begin{array} { r } { T = \frac { n \epsilon } { \sqrt { p } } } \end{array}$ $p < n ^ { 2 }$
+
+$$
+\mathbb { E } [ F \left( \mathbf { x } _ { T } \right) - F \left( \mathbf { x } _ { * } \right) ] = { \mathcal { O } } \left( { \frac { { \sqrt { p } } L ^ { 2 } \log ( n ) } { n \epsilon \nu } } \right) .
+$$
+
+We note that the analysis of Bassily et al. (2014) yields E[F (xT )−F (x∗)] = O  √pL2 log2(n)nµ  if setting $\begin{array} { r } { T = \frac { n \epsilon } { \sqrt { p } } } \end{array}$ , w till depends on the minimum curvature. Theorem 5 shows the $\nu = 0$
+
+Theorem 5 (Utility guarantee, $\nu = 0$ .). Suppose $F$ is $L$ -Lipschitz. Assume $\| \pmb { x } _ { t } \| \le D$ for $t \in [ T ]$ . Choose $\sigma$ based on Lemma $\mathit { 1 }$ to guarantee $( \epsilon , \delta )$ -DP. Let $G = L \sqrt { 1 + p \sigma ^ { 2 } }$ , set ηt = DG√t and $T = n ^ { 2 } \epsilon ^ { 2 }$ , we have
+
+$$
+\mathbb { E } [ F \left( \pmb { x } _ { T } \right) - F \left( \pmb { x } _ { \ast } \right) ] = \mathcal { O } \left( \frac { \sqrt { p \log \left( 1 / \delta \right) } L \log \left( n \right) } { n \epsilon } \right) .
+$$
+
+This utility guarantee can be derived from Theorem 2 in (Shamir $\&$ Zhang, 2013).
+
+# 3.4 Discussion on three perturbation approaches.
+
+In this section, we briefly discuss two other perturbation approaches and compare them to the gradient perturbation approach.
+
+Output perturbation (Wu et al., 2017; Zhang et al., 2017) perturbs the learning algorithm after training. It adds noise to the resulting model of non-private learning process. The magnitude of perturbation noise is propositional to the maximum influence one record can cause on the learned model. Take the gradient descent algorithm as an example. At each step, the gradient of different records would diverge the two sets of parameters generated by neighboring datasets, the maximum distance expansion is related to the Lipschitz coefficient. At the same time, the gradient of the same records in two datasets would shrink the parameter distance because of the contraction effect of the gradient update. The contraction effect depends on the smooth and strongly convex coefficient. Smaller strongly convex coefficient leads to weaker contraction. The sensitivity of output perturbation algorithm is the upper bound on the largest possible final distance between two sets of parameters.
+
+Objective perturbation (Chaudhuri et al., 2011; Kifer et al., 2012; Iyengar et al., 2019) perturbs the objective function before training. It requires the objective function to be strongly convex to guarantee the uniqueness of the solution. It first adds $L _ { 2 }$ regularization to obtain strong convexity if the original objective is not strongly convex. Then it perturbs the objective with a random linear term. The sensitivity of objective perturbation is the maximum change of the minimizer that one record can produce. Chaudhuri et al. (2011) and Kifer et al. (2012) use the largest and the smallest eigenvalue (i.e. the smooth and strongly convex coefficient) of the objective’s Hessian matrix to upper bound such change.
+
+In comparison, gradient perturbation is more flexible than output/objective perturbation. For example, to bound the sensitivity, gradient perturbation only requires Lipschitz coefficient which can be easily obtained by using the gradient clipping technique. However, both output and objective perturbation further need to compute the smooth coefficient, which is hard for some common objectives such as softmax regression.
+
+More critically, output/objective perturbation cannot utilize the expected curvature condition because their training process does not contain perturbation noise. Moreover, they have to consider the worst performance of learning algorithm. That is because DP makes the worst case assumption on query function and output/objective perturbation treat the whole learning algorithm as a single query to private dataset. This explains why their utility guarantee depends on the worst curvature of the objective.
+
+# 4 Experiment
+
+In this section, we evaluate the performance of DP-GD and DP-SGD on multiple real world datasets. We use the benchmark datasets provided by Iyengar et al. (2019). Objective functions are logistic regression and softmax regression for binary and multi-class datasets, respectively.
+
+Datasets. The benchmark datasets includes two multi-class datasets (MNIST, Covertype) and five binary datasets, and three of them are high dimensional (Gisette, Real-sim, RCV1).
+
+Table 2: Algorithm validation accuracy (in $\%$ ) on various kinds of real world datasets. Privacy parameter $\epsilon$ is 0.1 for binary dataset and 1 for multi-classes datasets.   
+
+<table><tr><td></td><td>KDDCup99</td><td>Adult</td><td>MNIST</td><td>Covertype</td><td>Gisette</td><td>Real-sim</td><td>RCV1</td></tr><tr><td>Non private</td><td>99.1</td><td>84.8</td><td>91.9</td><td>71.2</td><td>96.6</td><td>93.3</td><td>93.5</td></tr><tr><td>AMP1</td><td>97.5</td><td>79.3</td><td>71.9</td><td>64.3</td><td>62.8</td><td>73.1</td><td>64.5</td></tr><tr><td>Out-SGD</td><td>98.1</td><td>77.4</td><td>69.4</td><td>62.4</td><td>62.3</td><td>73.2</td><td>66.7</td></tr><tr><td>DP-SGD</td><td>98.7</td><td>80.4</td><td>87.5</td><td>67.7</td><td>63.0</td><td>73.8</td><td>70.4</td></tr><tr><td>DP-GD</td><td>98.7</td><td>80.9</td><td>88.6</td><td>66.2</td><td>67.3</td><td>76.1</td><td>74.9</td></tr></table>
+
+![](images/e4bca66c83380d29bc2d6fc58d3bc916e6e2c9f242addde6ddb24f85443a6db7.jpg)  
+Figure 3: Algorithm validation accuracy (in $\%$ ) with varying . NP represents non-private baseline. Detailed description about evaluated datasets can be found in Table 3.
+
+Following Iyengar et al. (2019), we use $8 0 \%$ data for training and the rest for testing. Detailed description of datasets can be found in Appendix B
+
+Implementation details. We track Rényi differentialy privacy $( R D P )$ (Mironov, 2017) and convert it to $( \epsilon , \delta )$ -DP. Running step $T$ is chosen from $\{ 5 0 , 2 0 0 , 8 0 0 \}$ for both DP-GD and DP-SGD. For DP-SGD, we use moments accountant to track the privacy loss and the sampling ratio is set as 0.1. The standard deviation of the added noise $\sigma$ is set to be the smallest value such that the privacy budget is allowable to run desired steps. We ensure each loss function is Lipschitz by clipping individual gradient. The method in Goodfellow (2015) allows us to clip individual gradient efficiently. Clipping threshold is set as 1 (0.5 for high dimensional datasets because of the sparse gradient). For DP-GD, learning rate is chosen from $\{ 0 . 1 , 1 . 0 , 5 . 0 \}$ $( \{ 0 . 2 , 2 . 0 , 1 0 . 0 \}$ for high dimensional datasets). The learning rate of DP-SGD is twice as large as DP-GD and it is divided by 2 at the middle of training. Privacy parameter $\delta$ is set as $\textstyle { \frac { 1 } { n ^ { 2 } } }$ . The $l _ { 2 }$ regularization coefficient is set as $1 \times 1 0 ^ { - 4 }$ . All reported numbers are averaged over 20 runs.
+
+Baseline algorithms. The baseline algorithms include state-of-the-art objective and output perturbation algorithms. For objective perturbation, we use Approximate Minima Perturbation (AMP) (Iyengar et al., 2019). For output perturbation, we use the algorithm in Wu et al. (2017) (Output perturbation SGD). We adopt the implementation and hyperparameters in Iyengar et al. (2019) for both algorithms. For multi-class classification tasks, Wu et al. (2017) and Iyengar et al. (2019) divide the privacy budget evenly and train multiple binary classifiers because their algorithms need to compute smooth coefficient before training and therefore are not directly applicable to softmax regression.
+
+Experiment results. The validation accuracy results for all evaluated algorithms with $\epsilon = 0 . 1$ (1.0 for multi-class datasets) are presented in Table 2. We also plot the accuracy results with varying $\epsilon$ in Figure 3. These results confirm our theory in Section 3: gradient perturbation achieves better performance than other perturbation methods as it leverages the average curvature.
+
+# 5 Conclusion
+
+In this paper, we show the privacy noise actually helps optimization analysis, which can be used to improve the utility guarantee of both DP-GD and DP-SGD. Our result theoretically justifies the empirical superiority of gradient perturbation over other methods and advance the state of the art utility guarantee of DP-ERM algorithms. Experiments on real world datasets corroborate our theoretical findings nicely. In the future, it is interesting to consider how to utilize the expected curvature condition to improve the utility guarantee of other gradient perturbation based algorithms.
+
+# References
+
+Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In ACM SIGSAC Conference on Computer and Communications Security, 2016.
+
+John M Abowd. The challenge of scientific reproducibility and privacy protection for statistical agencies. Census Scientific Advisory Committee, 2016.
+
+Naman Agarwal, Ananda Theertha Suresh, Felix Xinnan X Yu, Sanjiv Kumar, and Brendan McMahan. cpsgd: Communication-efficient and differentially-private distributed sgd. In Advances in Neural Information Processing Systems, 2018.
+
+Raef Bassily, Adam Smith, and Abhradeep Thakurta. Differentially private empirical risk minimization: Efficient algorithms and tight error bounds. Annual Symposium on Foundations of Computer Science, 2014.
+
+Kamalika Chaudhuri and Claire Monteleoni. Privacy-preserving logistic regression. In Advances in Neural Information Processing Systems, 2009.
+
+Kamalika Chaudhuri, Claire Monteleoni, and Anand D Sarwate. Differentially private empirical risk minimization. Journal of Machine Learning Research, 2011.
+
+Bolin Ding, Janardhan Kulkarni, and Sergey Yekhanin. Collecting telemetry data privately. In Advances in Neural Information Processing Systems, 2017.
+
+Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In Annual International Conference on the Theory and Applications of Cryptographic Techniques, 2006a.
+
+Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography conference, 2006b.
+
+Cynthia Dwork, Aaron Roth, et al. The algorithmic foundations of differential privacy. Foundations and Trends
+
+Úlfar Erlingsson, Vasyl Pihur, and Aleksandra Korolova. Rappor: Randomized aggregatable privacypreserving ordinal response. In Proceedings of the 2014 ACM SIGSAC conference on computer and communications security, 2014.
+
+Vitaly Feldman, Ilya Mironov, Kunal Talwar, and Abhradeep Thakurta. Privacy amplification by iteration. In 2018 IEEE 59th Annual Symposium on Foundations of Computer Science (FOCS), 2018.
+
+Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model inversion attacks that exploit confidence information and basic countermeasures. In ACM SIGSAC Conference on Computer and Communications Security, 2015.
+
+Ian Goodfellow. Efficient per-example gradient computations. arXiv preprint arXiv:1510.01799, 2015.
+
+Briland Hitaj, Giuseppe Ateniese, and Fernando Pérez-Cruz. Deep models under the gan: information leakage from collaborative deep learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, 2017.
+
+Roger Iyengar, Joseph P Near, Dawn Song, Om Thakkar, Abhradeep Thakurta, and Lun Wang. Towards practical differentially private convex optimization. In IEEE Symposium on Security and Privacy, 2019.
+
+Bargav Jayaraman, Lingxiao Wang, David Evans, and Quanquan Gu. Distributed learning without distress: Privacy-preserving empirical risk minimization. In Advances in Neural Information Processing Systems, 2018.
+
+Daniel Kifer, Adam Smith, and Abhradeep Thakurta. Private convex empirical risk minimization and high-dimensional regression. In Conference on Learning Theory, 2012.
+
+Jaewoo Lee and Daniel Kifer. Concentrated differentially private gradient descent with adaptive per-iteration privacy budget. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2018.
+
+Robert McMillan. Apple tries to peek at user habits without violating privacy. The Wall Street Journal, 2016.
+
+Ilya Mironov. Rényi differential privacy. In IEEE 30th Computer Security Foundations Symposium (CSF), 2017.
+
+Sahand N Negahban, Pradeep Ravikumar, Martin J Wainwright, Bin Yu, et al. A unified framework for high-dimensional analysis of $m$ -estimators with decomposable regularizers. Statistical Science, 27(4):538–557, 2012.
+
+Md Atiqur Rahman, Tanzila Rahman, Robert Laganiere, Noman Mohammed, and Yang Wang. Membership inference attack against differentially private deep learning model. Transactions on Data Privacy, 2018.
+
+Arun Rajkumar and Shivani Agarwal. A differentially private stochastic gradient descent algorithm for multiparty classification. In Artificial Intelligence and Statistics, 2012.
+
+Ohad Shamir and Tong Zhang. Stochastic gradient descent for non-smooth optimization: Convergence results and optimal averaging schemes. In International Conference on Machine Learning, 2013.
+
+Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In IEEE Symposium on Security and Privacy (SP), 2017.
+
+Adam Smith, Abhradeep Thakurta, and Jalaj Upadhyay. Is interaction necessary for distributed private learning? In IEEE Symposium on Security and Privacy (SP). IEEE, 2017.
+
+Shuang Song, Kamalika Chaudhuri, and Anand D Sarwate. Stochastic gradient descent with differentially private updates. In Global Conference on Signal and Information Processing (GlobalSIP), 2013 IEEE, 2013.
+
+Kunal Talwar, Abhradeep Guha Thakurta, and Li Zhang. Nearly optimal private lasso. In Advances in Neural Information Processing Systems, 2015.
+
+Di Wang, Minwei Ye, and Jinhui Xu. Differentially private empirical risk minimization revisited: Faster and more general. In Advances in Neural Information Processing Systems, 2017.
+
+Lingxiao Wang and Quanquan Gu. Differentially private iterative gradient hard thresholding for sparse learning. In 28th International Joint Conference on Artificial Intelligence, 2019.
+
+Xi Wu, Matthew Fredrikson, Somesh Jha, and Jeffrey F Naughton. A methodology for formalizing model-inversion attacks. In 2016 IEEE 29th Computer Security Foundations Symposium (CSF), 2016.
+
+Xi Wu, Fengan Li, Arun Kumar, Kamalika Chaudhuri, Somesh Jha, and Jeffrey Naughton. Bolt-on differential privacy for scalable stochastic gradient descent-based analytics. In ACM International Conference on Management of Data, 2017.
+
+Jiaqi Zhang, Kai Zheng, Wenlong Mou, and Liwei Wang. Efficient private erm for smooth objectives. In International Joint Conference on Artificial Intelligence, 2017.
+
+# Appendix A Proofs Related to DP-GD and DP-SGD
+
+Proof of Theorem 1. Let $\pmb { x } _ { 1 } , \ldots , \pmb { x } _ { t }$ be the path generated by optimization procedure. Since $\scriptstyle { \mathbf { x } } _ { t }$ contains Gaussian perturbation noise ${ z t - 1 }$ , Definition 3 gives us
+
+$$
+\begin{array} { r } { \mathbb { E } _ { z _ { t - 1 } } \big [ \langle { \pmb x } _ { t } - { \pmb x } _ { * } , \nabla F \left( { \pmb x } _ { t } \right) \rangle \big ] \geq \nu _ { t } \mathbb { E } _ { z _ { t - 1 } } \big [ \big \| { \pmb x } _ { t } - { \pmb x } _ { * } \big \| ^ { 2 } \big ] . } \end{array}
+$$
+
+Since $F ^ { \prime }$ is $\beta$ -smooth, we have
+
+$$
+\langle { \pmb x } _ { t } - { \pmb x } _ { * } , \nabla F \left( { \pmb x } _ { t } \right) \rangle \geq \frac { 1 } { \beta } \left\| \nabla F \left( { \pmb x } _ { t } \right) \right\| ^ { 2 } .
+$$
+
+Take linear combination of above inequalities,
+
+$$
+\begin{array} { r l r } & { } & { \mathbb { E } _ { z _ { t - 1 } } [ \langle x _ { t } - x _ { * } , \nabla F \left( { \pmb x } _ { t } \right) \rangle ] \ge \theta \nu _ { t } \mathbb { E } _ { z _ { t - 1 } } [ \| { \pmb x } _ { t } - { \pmb x } _ { * } \| ^ { 2 } ] + \frac { ( 1 - \theta ) } { \beta } \mathbb { E } _ { z _ { t - 1 } } [ \| \nabla F \left( { \pmb x } _ { t } \right) \| ^ { 2 } ] } \\ & { } & \\ & { } & { \ge \theta \nu \mathbb { E } _ { z _ { t - 1 } } [ \| { \pmb x } _ { t } - { \pmb x } _ { * } \| ^ { 2 } ] + \frac { ( 1 - \theta ) } { \beta } \mathbb { E } _ { z _ { t - 1 } } [ \| \nabla F \left( { \pmb x } _ { t } \right) \| ^ { 2 } ] . } \end{array}
+$$
+
+Let $r _ { t } = \| \pmb { x } _ { t } - \pmb { x } _ { * } \|$ be the solution error at step $t$ . We have the following inequalities between $r _ { t + 1 }$ and $r _ { t }$ .
+
+$$
+\begin{array} { r l } & { r _ { t + 1 } ^ { 2 } = \left. x _ { t } - \eta \nabla F \left( { \pmb x } _ { t } \right) - \eta z _ { t } - { \pmb x } _ { * } \right. ^ { 2 } , } \\ & { \qquad = \left. { \pmb x } _ { t } - { \pmb x } _ { * } \right. ^ { 2 } - 2 \eta \langle \nabla F \left( { \pmb x } _ { t } \right) + z _ { t } , { \pmb x } _ { t } - { \pmb x } _ { * } \rangle + \eta ^ { 2 } \left. \nabla F \left( { \pmb x } _ { t } \right) + z _ { t } \right. ^ { 2 } . } \end{array}
+$$
+
+Take expectation with respect to $\scriptstyle { \mathcal { Z } } _ { t }$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } _ { z _ { t } } [ r _ { t + 1 } ^ { 2 } ] \le \| { \pmb x } _ { t } - { \pmb x } _ { * } \| ^ { 2 } - 2 \eta \langle \nabla F \left( { \pmb x } _ { t } \right) , { \pmb x } _ { t } - { \pmb x } _ { * } \rangle + \eta ^ { 2 } \| \nabla F \left( { \pmb x } _ { t } \right) \| ^ { 2 } + p \eta ^ { 2 } \sigma _ { t } ^ { 2 } . } \end{array}
+$$
+
+Further take expectation with respect to ${ \boldsymbol { \mathbf { \mathit { z } } } } _ { t - 1 }$ and use Eq 2, we have
+
+$$
+\begin{array} { r l } & { \mathfrak { L } _ { \mathfrak { z } _ { t } , \mathfrak { z } _ { t - 1 } } \big [ r _ { t + 1 } ^ { 2 } \big ] \leq \mathbb { E } _ { \mathfrak { z } _ { t - 1 } } \big [ \big \| x _ { t } - \mathfrak { x } _ { * } \big \| ^ { 2 } \big ] - 2 \eta \mathbb { E } _ { \mathfrak { z } _ { t - 1 } } \big [ \langle \nabla F \left( \mathfrak { x } _ { t } \right) , \mathfrak { x } _ { t } - \mathfrak { x } _ { * } \rangle \big ] + \eta ^ { 2 } \mathbb { E } _ { \mathfrak { z } _ { t - 1 } } \big [ \big \| \nabla F \left( \mathfrak { x } _ { t } \right) \big \| ^ { 2 } \big ] + p \eta ^ { 2 } \sigma _ { t } ^ { 2 } , } \\ & { \qquad \leq \left( 1 - 2 \left( 1 - \theta \right) \eta \nu \right) \mathbb { E } _ { \mathfrak { z } _ { t - 1 } } \big [ r _ { t } ^ { 2 } \big ] + \left( \eta ^ { 2 } - \frac { 2 \eta \theta } { \beta } \right) \mathbb { E } _ { \mathfrak { z } _ { t - 1 } } \big [ \big \| \nabla F \left( \mathfrak { x } _ { t } \right) \big \| ^ { 2 } \big ] + p \eta ^ { 2 } \sigma _ { t } ^ { 2 } . } \end{array}
+$$
+
+Set $\textstyle \theta = { \frac { 1 } { 2 } }$ and $\begin{array} { r } { \eta \le { \frac { 1 } { \beta } } } \end{array}$ ,
+
+$$
+\begin{array} { r } { \mathbb { E } _ { z _ { t } , z _ { t - 1 } } [ r _ { t + 1 } ^ { 2 } ] \leq ( 1 - \eta \nu ) \mathbb { E } _ { z _ { t - 1 } } [ r _ { t } ^ { 2 } ] + p \eta ^ { 2 } \sigma _ { t } ^ { 2 } . } \end{array}
+$$
+
+Applying Eq (6) and taking expectation with respect to $z _ { t } , z _ { t - 1 } , \cdots , z _ { 1 }$ iteratively yields
+
+$$
+\mathbb { E } [ r _ { t + 1 } ^ { 2 } ] \le \left( 1 - \eta \nu \right) ^ { t } r _ { 1 } ^ { 2 } + { p \eta } ^ { 2 } \sum _ { i = 1 } ^ { t } { ( 1 - \eta \nu ) } ^ { t - i } \sigma _ { i } ^ { 2 } .
+$$
+
+Uniform privacy budget allocation scheme sets
+
+$$
+\sigma _ { t } ^ { 2 } = \Theta \left( \frac { T L ^ { 2 } \log ( 1 / \delta ) } { n ^ { 2 } \epsilon ^ { 2 } } \right) .
+$$
+
+Therefore
+
+$$
+\mathbb { E } [ r _ { T + 1 } ^ { 2 } ] \le \left( 1 - \eta \nu \right) ^ { T } r _ { 1 } ^ { 2 } + \Theta \left( \frac { p \eta T L ^ { 2 } \log ( 1 / \delta ) } { \nu n ^ { 2 } \epsilon ^ { 2 } } \right) .
+$$
+
+Set $\begin{array} { r } { T \ge \frac { 2 \log ( n ) } { \eta \nu } } \end{array}$ , we have
+
+$$
+\begin{array} { c } { \displaystyle \left( 1 - \eta \nu \right) ^ { T } r _ { 1 } ^ { 2 } = \exp \left( \frac { \log \left( 1 - \eta \nu \right) \log \left( n ^ { 2 } \right) } { \eta \nu } \right) r _ { 1 } ^ { 2 } = \exp \left( \log ( 1 / n ^ { 2 } ) \frac { 1 } { \eta \nu } \log ( 1 + \frac { \eta \nu } { 1 - \eta \nu } ) \right) r _ { 1 } ^ { 2 } , } \\ { \displaystyle \qquad \leq \left( \frac { 1 } { n ^ { 2 } } \right) ^ { \frac { 1 } { \eta \nu } \log ( 1 + \frac { \eta \nu } { 1 - \eta \nu } ) } r _ { 1 } ^ { 2 } < \frac { r _ { 1 } ^ { 2 } } { n ^ { 2 } } . } \end{array}
+$$
+
+Last inequality holds because $\begin{array} { r } { \frac { 1 } { \eta \nu } \log ( 1 + \frac { \eta \nu } { 1 - \eta \nu } ) > 1 } \end{array}$ for $\begin{array} { r } { \frac { 1 } { \eta \nu } \geq \frac { \beta } { \nu } \geq 1 } \end{array}$
+
+Therefore, for $\begin{array} { r } { T \geq \frac { 2 \log ( n ) } { \eta \nu } } \end{array}$ , we have the excepted solution error $\mathbb { E } [ r _ { T + 1 } ^ { 2 } ]$ satisfies
+
+$$
+\mathbb { E } [ r _ { T + 1 } ^ { 2 } ] = \mathcal { O } \left( \frac { p \eta T L ^ { 2 } \log ( 1 / \delta ) } { \nu n ^ { 2 } \epsilon ^ { 2 } } \right) .
+$$
+
+Since $F ( { \pmb x } )$ is $\beta$ -smooth, we have
+
+$$
+F ( \pmb { x } ) - F ( \pmb { x } _ { \ast } ) \leq \frac { \beta } { 2 } \left. \pmb { x } - \pmb { x } _ { \ast } \right. ^ { 2 } .
+$$
+
+Using Eq (10) and Eq (11), we have the excepted excess risk satisfies
+
+$$
+\mathbb { E } [ F ( { \pmb x } _ { T + 1 } ) - F ( { \pmb x } _ { \ast } ) ] = { \mathcal O } \left( \frac { \beta p \eta T L ^ { 2 } \log ( 1 / \delta ) } { \nu n ^ { 2 } \epsilon ^ { 2 } } \right)
+$$
+
+for $\begin{array} { r } { T \ge \frac { 2 \log ( n ) } { \eta \nu } } \end{array}$ . The utility bound is minimized when $\begin{array} { r } { T = \frac { 2 \log ( n ) } { \eta \nu } } \end{array}$
+
+Proof of Theorem $\mathcal { L }$ . The smooth condition gives us,
+
+$$
+\begin{array} { l } { \displaystyle F ( { \pmb x } _ { t + 1 } ) \leq F ( { \pmb x } _ { t } ) + \langle \nabla F ( { \pmb x } _ { t } ) , { \pmb x } _ { t + 1 } - { \pmb x } _ { t } \rangle + \displaystyle \frac { \beta } { 2 } \left\| { \pmb x } _ { t + 1 } - { \pmb x } _ { t } \right\| ^ { 2 } } \\ { \displaystyle \qquad = F ( { \pmb x } _ { t } ) - \eta \langle \nabla F ( { \pmb x } _ { t } ) , \nabla F ( { \pmb x } _ { t } ) + { \pmb z } _ { t } \rangle + \displaystyle \frac { \beta \eta ^ { 2 } } { 2 } \left\| \nabla F ( { \pmb x } _ { t } ) + { \pmb z } _ { t } \right\| ^ { 2 } . } \end{array}
+$$
+
+Take expectation with respect to $\scriptstyle { \mathcal { Z } } _ { t }$ and substitute $\begin{array} { r } { \eta = { \frac { 1 } { \beta } } } \end{array}$
+
+$$
+\mathbb { E } _ { z _ { t } } [ F ( { \pmb x } _ { t + 1 } ) ] = F ( { \pmb x } _ { t } ) - \frac { 1 } { 2 \beta } \left\| \nabla F ( { \pmb x } _ { t } ) \right\| ^ { 2 } + \frac { 1 } { 2 \beta } p \sigma _ { t } ^ { 2 } .
+$$
+
+Subtract $F ( { \pmb x } _ { * } )$ on both sides and use convexity,
+
+$$
+\begin{array} { r l } { \displaystyle \mathbb { E } _ { z _ { t } } [ F ( { \boldsymbol x } _ { t + 1 } ) - F ( { \boldsymbol x } _ { * } ) ] = F ( { \boldsymbol x } _ { t } ) - F ( { \boldsymbol x } _ { * } ) - \frac { 1 } { 2 \beta } \| \nabla F ( { \boldsymbol x } _ { t } ) \| ^ { 2 } + \frac { 1 } { 2 \beta } p \sigma _ { t } ^ { 2 } } & { } \\ { \displaystyle \le \langle \nabla F ( { \boldsymbol x } _ { t } ) , { \boldsymbol x } _ { t } - { \boldsymbol x } _ { * } \rangle - \frac { 1 } { 2 \beta } \| \nabla F ( { \boldsymbol x } _ { t } ) \| ^ { 2 } + \frac { 1 } { 2 \beta } p \sigma _ { t } ^ { 2 } . } & { } \end{array}
+$$
+
+Substitute $\nabla F ( { \pmb x } _ { t } ) = \beta ( { \pmb x } _ { t } - { \pmb x } _ { t + 1 } ) - { \pmb z } _ { t }$ ,
+
+$$
+\begin{array} { r l } { \mathbb { E } _ { \mathbf { z } _ { t } } [ F ( \mathbf { x } _ { t + 1 } ) - F ( \mathbf { x } _ { * } ) ] \leq \beta \langle \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } , \mathbf { x } _ { t } - \mathbf { x } _ { * } \rangle - \frac { 1 } { 2 \beta } \mathbb { E } _ { \mathbf { z } _ { t } } [ \left. \beta ( \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } ) - z _ { t } \right. ^ { 2 } ] + \frac { 1 } { 2 \beta } p \sigma _ { t } ^ { 2 } } & { } \\ { = \beta \langle \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } , \mathbf { x } _ { t } - \mathbf { x } _ { * } \rangle - \frac { \beta } { 2 } \left. \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } \right. ^ { 2 } - \mathbb { E } _ { \mathbf { z } _ { t } } \langle \mathbf { x } _ { t + 1 } , z _ { t } \rangle } & { } \\ { = \beta \langle \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } , \mathbf { x } _ { t } - \mathbf { x } _ { * } \rangle - \frac { \beta } { 2 } \left. \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } \right. ^ { 2 } - \mathbb { E } _ { \mathbf { z } _ { t } } \langle \mathbf { x } _ { t } - \boldsymbol { \eta } \nabla F ( \mathbf { x } _ { t } ) - \boldsymbol { \eta } z _ { t } , z _ { t } \rangle } & { } \\ { = \beta \langle \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } , \mathbf { x } _ { t } - \mathbf { x } _ { * } \rangle - \frac { \beta } { 2 } \left. \mathbf { x } _ { t } - \mathbf { x } _ { t + 1 } \right. ^ { 2 } + \frac { 1 } { \beta } p \sigma _ { t } ^ { 2 } } & { } \\ { } & { = \frac { \beta } { 2 } ( \Vert \mathbf { x } _ { t } - \mathbf { x } _ { * } \Vert ^ { 2 } - \Vert \mathbf { x } _ { t + 1 } - \mathbf { x } _ { * } \Vert ^ { 2 } ) + \frac { 1 } { \beta } p \sigma _ { t } ^ { 2 } . } \end{array}
+$$
+
+Summing over $t = 1 , \ldots , T ^ { \prime }$ and take expectation with respect to $z _ { 1 } , \dots , z _ { T }$ ,
+
+$$
+\sum _ { t = 1 } ^ { T } \mathbb { E } [ F ( \pmb { x } _ { t + 1 } ) - F ( \pmb { x } _ { * } ) ] \leq \frac { \beta } { 2 } \left. \pmb { x } _ { 1 } - \pmb { x } _ { * } \right. ^ { 2 } + \sum _ { t = 1 } ^ { T } \frac { 1 } { \beta } p \sigma _ { t } ^ { 2 } .
+$$
+
+Use convexity,
+
+$$
+\begin{array} { r l r } {  { \mathbb { E } [ F ( \bar { \pmb { x } } ) - F ( { \pmb x } _ { * } ) ] \le \frac { \beta } { 2 T } \| { \pmb x } _ { 1 } - { \pmb x } _ { * } \| ^ { 2 } + \frac { 1 } { \beta } p \sigma ^ { 2 } } } \\ & { } & { \le \frac { \beta } { 2 T } \| { \pmb x } _ { 1 } - { \pmb x } _ { * } \| ^ { 2 } + \Theta ( \frac { L ^ { 2 } p T \log ( 1 / \delta ) } { \beta n ^ { 2 } \epsilon ^ { 2 } } ) } \end{array}
+$$
+
+Choose T = nβ√ , √p， we have
+
+$$
+\mathbb { E } [ F ( \bar { \pmb x } ) - F ( { \pmb x } _ { \ast } ) ] = \mathcal { O } \left( \frac { \sqrt { p } L ^ { 2 } \log ( 1 / \delta ) } { n \epsilon } \right) .
+$$
+
+Proof of Theorem 3 and 4. We start by giving a useful lemma.
+
+Lemma 2. Choose $\begin{array} { r } { \eta _ { t } = \frac { 1 } { \nu t } } \end{array}$ , the expected solution error of $_ { x t }$ in Algorithm $\mathcal { Q }$ for any $t > 1$ satisfies
+
+$$
+\mathbb { E } [ \| \pmb { x } _ { t } - \pmb { x } _ { * } \| ^ { 2 } ] \le \frac { 2 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { t \nu ^ { 2 } } ,
+$$
+
+Proof of Lemma $\mathcal { Z }$ . We have
+
+$$
+\begin{array} { r l } & { \| x _ { t + 1 } - x _ { * } \| ^ { 2 } = \| x _ { t } - \eta _ { t } g _ { t } - \eta _ { t } z _ { t } - x _ { * } \| ^ { 2 } } \\ & { \qquad = \| x _ { t } - x _ { * } \| ^ { 2 } - 2 \eta _ { t } \langle x _ { t } - x _ { * } , g _ { t } + z _ { t } \rangle + \eta _ { t } ^ { 2 } \left\| g _ { t } \right\| ^ { 2 } - 2 \eta _ { t } ^ { 2 } \langle g _ { t } , z _ { t } \rangle + \eta _ { t } ^ { 2 } \left\| z _ { t } \right\| ^ { 2 } . } \end{array}
+$$
+
+Take expectation with respect to perturbation noise $\scriptstyle { \mathcal { Z } } _ { t }$ and uniform sampling, we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { z _ { t } , i _ { t } } [ \| { \boldsymbol x } _ { t + 1 } - { \boldsymbol x } _ { * } \| ^ { 2 } ] = \mathbb { E } _ { z _ { t } , i _ { t } } [ \| { \boldsymbol x } _ { t } - \eta _ { t } { \boldsymbol g } _ { t } - \eta _ { t } z _ { t } - { \boldsymbol x } _ { * } \| ^ { 2 } ] } \\ & { \qquad \le \| { \boldsymbol x } _ { t } - { \boldsymbol x } _ { * } \| ^ { 2 } - 2 \eta _ { t } \langle { \boldsymbol x } _ { t } - { \boldsymbol x } _ { * } , \nabla F ( { \boldsymbol x } _ { t } ) \rangle + \eta _ { t } ^ { 2 } L ^ { 2 } + p \eta _ { t } ^ { 2 } L ^ { 2 } \sigma ^ { 2 } . } \end{array}
+$$
+
+Further take expectation to ${ \boldsymbol { z } } _ { t - 1 }$ and apply Definition 3,
+
+$$
+\begin{array} { r } { \begin{array} { r } { \mathbb { E } _ { z _ { t } , z _ { t - 1 } , i _ { t } } [ \| { \boldsymbol x } _ { t + 1 } - { \boldsymbol x } _ { * } \| ^ { 2 } ] \leq \left( 1 - 2 \nu _ { t } \eta _ { t } \right) \mathbb { E } _ { z _ { t - 1 } } [ \| { \boldsymbol x } _ { t } - { \boldsymbol x } _ { * } \| ^ { 2 } ] + \eta _ { t } ^ { 2 } L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } \\ { \leq \left( 1 - 2 \nu \eta _ { t } \right) \mathbb { E } _ { z _ { t - 1 } } [ \| { \boldsymbol x } _ { t } - { \boldsymbol x } _ { * } \| ^ { 2 } ] + \eta _ { t } ^ { 2 } L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) . } \end{array} } \end{array}
+$$
+
+Now we use induction to conduct the proof. Substitute $\begin{array} { r } { \eta _ { t } = \frac { 1 } { t \nu } } \end{array}$ into Eq 21, we have Lemma 2 hold for $t = 2$ .
+
+Assume $\begin{array} { r } { \mathbb { E } [ \left\| \pmb { x } _ { t } - \pmb { x } _ { * } \right\| ^ { 2 } ] \leq \frac { 2 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { t \nu ^ { 2 } } } \end{array}$ holds for $t > 2$ , then
+
+$$
+\begin{array} { r l r } {  { \mathbb { E } [ \| { \pmb x } _ { t + 1 } - { \pmb x } _ { * } \| ^ { 2 } ] \leq ( 1 - \frac { 2 } { t } ) \mathbb { E } [ \| { \pmb x } _ { t } - { \pmb x } _ { * } \| ^ { 2 } ] + \frac { L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { \nu ^ { 2 } t ^ { 2 } } } } \\ & { } & { \leq ( \frac { 1 } { t } - \frac { 2 } { t ^ { 2 } } ) \frac { 2 L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { \nu ^ { 2 } } + \frac { L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { \nu ^ { 2 } t ^ { 2 } } } \\ & { } & { = ( \frac { 2 } { t } - \frac { 3 } { t ^ { 2 } } ) \frac { L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { \nu ^ { 2 } } \leq \frac { 2 L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { ( t + 1 ) \nu ^ { 2 } } . } \end{array}
+$$
+
+It’s easy to check that Eq 20 holds for arbitrary $\textbf { \em x }$ rather than $^ { x \ast }$ . Rearrange Eq 20 and take expectation, we have
+
+$$
+\mathbb { E } [ \langle x _ { t } - x , \nabla F \left( x _ { t } \right) \rangle ] \leq \frac { \mathbb { E } [ \Vert x _ { t } - x \Vert ^ { 2 } ] - \mathbb { E } [ \Vert x _ { t + 1 } - x \Vert ^ { 2 } ] } { 2 \eta _ { t } } + \frac { \eta _ { t } L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 } .
+$$
+
+Let $k$ be arbitrarily chosen from $\{ 1 , \ldots , \lfloor { T / 2 } \rfloor \}$ . Summing over the last $k + 1$ iterations and use convexity to lower bound $\langle { \pmb x } _ { t } - { \pmb x } , \nabla F \left( { \pmb x } _ { t } \right) \rangle$ by $F \left( { \pmb x } _ { t } \right) - F \left( { \pmb x } \right)$ ,
+
+$$
+\begin{array} { r l } { \displaystyle \sum _ { t = T - k } ^ { T } \mathbb { E } [ F ( { \pmb x } _ { t } ) - F ( { \pmb x } ) ] \leq \frac { \mathbb { E } [ \| { \pmb x } _ { T - k } - { \pmb x } \| ^ { 2 } ] } { 2 \eta _ { T - k } } + \frac { 1 } { 2 } \displaystyle \sum _ { t = T - k + 1 } ^ { T } \mathbb { E } [ \| { \pmb x } _ { t } - { \pmb x } \| ^ { 2 } ] \left( \frac { 1 } { n _ { t } } - \frac { 1 } { n _ { t - 1 } } \right) } & { } \\ { - \frac { \mathbb { E } [ \| { \pmb x } _ { T + 1 } - { \pmb x } \| ^ { 2 } ] } { 2 \eta _ { T } } + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 } \displaystyle \sum _ { t = T - k } ^ { T } \eta _ { t } . } & { } \end{array}
+$$
+
+Substitute $\begin{array} { r } { \eta _ { t } = \frac { 1 } { \nu t } } \end{array}$ and follow the idea in Shamir & Zhang (2013) by choosing ${ \pmb x } = { \pmb x } _ { T - k }$ , we arrive at
+
+$$
+\sum _ { t = T - k } ^ { T } \mathbb { E } [ F \left( \pmb { x } _ { t } \right) - F \left( \pmb { x } _ { T - k } \right) ] \leq \frac { \nu } { 2 } \sum _ { t = T - k + 1 } ^ { T } \mathbb { E } [ \left. \pmb { x } _ { t } - \pmb { x } _ { T - k } \right. ^ { 2 } ] + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 \nu } \sum _ { t = T - k } ^ { T } \frac { 1 } { t } .
+$$
+
+Now we bound $\mathbb { E } [ \left. \pmb { x } _ { t } - \pmb { x } _ { T - k } \right. ^ { 2 } ]$ for $t \geq T ^ { \prime } - k$ ,
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ \| { \pmb x } _ { t } - { \pmb x } _ { T - k } \| ^ { 2 } ] \le 2 \mathbb { E } [ \| { \pmb x } _ { t } - { \pmb x } _ { * } \| ^ { 2 } ] + 2 \mathbb { E } [ \| { \pmb x } _ { T - k } - { \pmb x } _ { * } \| ^ { 2 } ] } \\ & { \le \frac { 4 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \nu ^ { 2 } } \left( \frac { 1 } { t } + \frac { 1 } { T - k } \right) \le \frac { 8 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \nu ^ { 2 } } \left( \frac { 1 } { T - k } \right) } \\ & { \le \frac { 1 6 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { T \nu ^ { 2 } } . } \end{array}
+$$
+
+Substitute Eq 26 into Eq 25,
+
+$$
+\sum _ { t = T - k } ^ { T } \mathbb { E } [ F \left( \pmb { x } _ { t } \right) - F \left( \pmb { x } _ { T - k } \right) ] \leq \frac { 8 k L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { T \nu } + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 \nu } \sum _ { t = T - k } ^ { T } \frac { 1 } { t } .
+$$
+
+Let $\begin{array} { r } { S _ { k } = \frac { 1 } { k + 1 } \sum _ { t = T - k } ^ { T } \mathbb { E } [ F \left( \pmb { x } _ { t } \right) ] } \end{array}$ be the averaged expected values of the last $k + 1$ iterations. We are interested in $S _ { 0 } - F \left( { \pmb x } _ { * } \right) = \mathbb { E } [ F \left( { \pmb x } _ { T } \right) ] - F \left( { \pmb x } _ { * } \right)$ . Now we derive an inequality between $S _ { k }$ and $S _ { k - 1 }$ . By definition,
+
+$$
+k S _ { k - 1 } = \left( k + 1 \right) S _ { k } - \mathbb { E } [ \mathbf { x } _ { T - k } ] .
+$$
+
+Rearrange Eq 27 to upper bound $- \mathbb { E } [ { \pmb x } _ { T - k } ]$ ,
+
+$$
+\begin{array} { l } { S _ { k - 1 } = \displaystyle \frac { k + 1 } { k } S _ { k } - \frac { \mathbb { E } \left[ { \pmb x } _ { T - k } \right] } { k } } \\ { \leq \frac { k + 1 } { k } S _ { k } - \frac { S _ { k } } { k } + \frac { 8 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \left( k + 1 \right) T \nu } + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 k \left( k + 1 \right) \nu } \displaystyle \sum _ { t = T - k } ^ { T } \frac { 1 } { t } } \\ { \leq S _ { k } + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 \nu } \left( \frac { 1 6 } { k T } + \frac { 1 } { k \left( k + 1 \right) } \displaystyle \sum _ { t = T - k } ^ { T } \frac { 1 } { t } \right) . } \end{array}
+$$
+
+Summing over $k = 1 , \dots , k = \lfloor T / 2 \rfloor$ ,
+
+$$
+S _ { 0 } \leq S _ { \lfloor T / 2 \rfloor } + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 \nu } \left( \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \frac { 1 6 } { k T } + \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \sum _ { t = T - k } ^ { T } \frac { 1 } { k \left( k + 1 \right) t } \right) .
+$$
+
+Now we bound $S _ { \lfloor T / 2 \rfloor } - F ( \pmb { x } _ { * } )$ . Choose ${ \boldsymbol { \mathbf { \mathit { x } } } } = { \boldsymbol { \mathbf { \mathit { x } } } } _ { \ast }$ and $\begin{array} { r } { \eta _ { t } = \frac { 1 } { t \nu } } \end{array}$ in Eq 24 ,
+
+$$
+\begin{array} { r l } & { \displaystyle \sum _ { t = \lfloor T / 2 \rfloor } ^ { T } \mathbb { E } [ F ( { \mathbf x } _ { t } ) - F ( { \mathbf x } _ { * } ) ] = \frac { \nu \left[ T / 2 \right] \mathbb { E } [ \left. { \mathbf x } _ { \lfloor T / 2 \rfloor } - \alpha _ { * } \right. ^ { 2 } ] } { 2 } + \frac { \nu } { 2 } \displaystyle \sum _ { t = \lfloor T / 2 \rfloor + 1 } ^ { T } \mathbb { E } [ \left. { \mathbf x } _ { t } - { \mathbf x } _ { * } \right. ^ { 2 } ] } \\ & { \qquad + \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { 2 } \displaystyle \sum _ { t = \lfloor T / 2 \rfloor } ^ { T } \frac { \nu } { 2 } } \\ & { \qquad \le \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \nu } \displaystyle ( 1 + \sum _ { t = \lfloor T / 2 \rfloor + 1 } ^ { T } \frac { 1 } { t } + \sum _ { t = \lceil T / 2 \rfloor } ^ { T } \frac { 1 } { 2 t } ) } \\ & { \qquad \le \frac { L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \nu } \displaystyle ( 1 + \frac { 3 } { 2 } \sum _ { t = \lfloor T / 2 \rfloor + 1 } ^ { T } \frac { 1 } { t } ) } \\ & { \qquad \le \frac { 4 L ^ { 2 } \left( 1 + p \sigma ^ { 2 } \right) } { \nu } . } \end{array}
+$$
+
+The second inequality uses Lemma 2. The last inequality holds because the fact that $\scriptstyle \sum _ { t = \lceil T / 2 \rceil } ^ { T ^ { \prime } } { \frac { 1 } { t } } \leq$ $\log ( 2 )$ . Dividing Eq 31 by $\lceil T / 2 \rceil$ ,
+
+$$
+S _ { \lfloor T / 2 \rfloor } - F ( \pmb { x } _ { \ast } ) \leq \frac { 8 L ^ { 2 } ( 1 + p \sigma ^ { 2 } ) } { T \nu } .
+$$
+
+We have $\begin{array} { r } { \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \frac { 1 6 } { k T } \leq \frac { 1 6 ( 1 + l o g ( T ) ) } { T } } \end{array}$ 16(1+log(T )) because it is harmonic sequence. Lastly,
+
+$$
+\begin{array} { r l r } {  { \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \sum _ { t = T - k } ^ { T } \frac { 1 } { k ( k + 1 ) t } \le \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \frac { \log ( 2 ) } { k ( k + 1 ) } } } \\ & { } & { \le \sum _ { k = 1 } ^ { \lfloor T / 2 \rfloor } \frac { \log ( 2 ) } { k ^ { 2 } } \le 2 \log ( 2 ) . } \end{array}
+$$
+
+Plugging these bounds into Eq 30, we have
+
+$$
+S _ { 0 } - F ( { \pmb x } _ { * } ) = \mathcal { O } \left( \frac { ( 1 + p \sigma ^ { 2 } ) L ^ { 2 } \log ( T ) } { T \nu } \right) .
+$$
+
+Choose $\begin{array} { r } { \sigma ^ { 2 } = \Theta \left( \frac { T l o g ( 1 / \delta ) } { n ^ { 2 } \epsilon ^ { 2 } } \right) } \end{array}$ to guarantee $( \epsilon , \delta )$ -DP. Set $T = n ^ { 2 } \epsilon ^ { 2 }$ , we have
+
+$$
+S _ { 0 } - F ( { \pmb x } _ { * } ) = \mathcal { O } \left( \frac { p L ^ { 2 } \log ( n ) l o g \left( 1 / \delta \right) } { n ^ { 2 } \epsilon ^ { 2 } \nu } \right) .
+$$
+
+Set $\begin{array} { r } { T = \frac { \pi \epsilon } { \sqrt { p } } } \end{array}$ and assume $p < n ^ { 2 }$ , we have
+
+$$
+S _ { 0 } - F ( \pmb { x } _ { * } ) = \mathcal { O } \left( \frac { \sqrt { p } L ^ { 2 } \log ( n ) } { n \epsilon \nu } \right) .
+$$
+
+# Appendix B Detailed description on benchmark datasets
+
+Table 3: Detailed description of seven real world datasets.   
+
+<table><tr><td rowspan=1 colspan=1>dataset</td><td rowspan=1 colspan=1>Adult</td><td rowspan=1 colspan=1>KDDCup99</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Covertype</td><td rowspan=1 colspan=1>Gisette</td><td rowspan=1 colspan=1>Real-sim</td><td rowspan=1 colspan=1>RCV1</td></tr><tr><td rowspan=1 colspan=1>#records</td><td rowspan=1 colspan=1>45220</td><td rowspan=1 colspan=1>70000</td><td rowspan=1 colspan=1>65000</td><td rowspan=1 colspan=1>581012</td><td rowspan=1 colspan=1>6000</td><td rowspan=1 colspan=1>72309</td><td rowspan=1 colspan=1>50000</td></tr><tr><td rowspan=1 colspan=1>#features</td><td rowspan=1 colspan=1>104</td><td rowspan=1 colspan=1>114</td><td rowspan=1 colspan=1>784</td><td rowspan=1 colspan=1>54</td><td rowspan=1 colspan=1>5000</td><td rowspan=1 colspan=1>20958</td><td rowspan=1 colspan=1>47236</td></tr><tr><td rowspan=1 colspan=1>#classes</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr></table>
+
+# Appendix C Comparison between Average and Minimum Curvatures on Different dataset
+
+In this section we plot the average and minimum curvatures in Figure 4 for another dataset KDDCup99. The objective function is still regularized logistic regression.
+
+As shown in Figure 4, the average curvature is still larger than the minimum curvature (especially when the regularization term is small). Despite this, the average curvature of KDDCup99 is smaller than Adult, this may be the reason why the improvement in Section 4 is larger for the Adult dataset.
+
+![](images/0f4f1dea782d3768ecb6ec38776f4982c99b6bd47380ccd10785b971e2967067.jpg)  
+Figure 4: Curvatures of regularized logistic regression on KDDCup99 dataset over training. Dot symbol represents average curvature and cross symbol represents minimum curvature.

parse/train/rkGG6s0qKQ/rkGG6s0qKQ.md

@@ -0,0 +1,343 @@
+# THE GAN LANDSCAPE: LOSSES, ARCHITECTURES, REGULARIZATION, AND NORMALIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative adversarial networks (GANs) are a class of deep generative models which aim to learn a target distribution in an unsupervised fashion. While they were successfully applied to many problems, training a GAN is a notoriously challenging task and requires a significant amount of hyperparameter tuning, neural architecture engineering, and a non-trivial amount of “tricks”. The success in many practical applications coupled with the lack of a measure to quantify the failure modes of GANs resulted in a plethora of proposed losses, regularization and normalization schemes, and neural architectures. In this work we take a sober view of the current state of GANs from a practical perspective. We reproduce the current state of the art and go beyond fairly exploring the GAN landscape. We discuss common pitfalls and reproducibility issues, open-source our code on Github, and provide pre-trained models on TensorFlow Hub.
+
+# 1 INTRODUCTION
+
+Deep generative models are a powerful class of unsupervised machine learning models. The power of these models was recently harnessed in a variety of applications, including image generation, learned compression, and domain transfer (Isola et al., 2017; Radford et al., 2016; Agustsson et al., 2018; Tschannen et al., 2018). Generative adversarial networks (Goodfellow et al., 2014) are one of the main approaches to learning such models in a fully unsupervised fashion. The GAN framework can be viewed as a two-player game where the first player, the generator, is learning to transform some simple input distribution (usually a standard multivariate Normal or uniform) to a distribution on the space of images, such that the second player, the discriminator, cannot tell whether the samples belong to the true distribution or were synthesized. Both players aim to minimize their own loss and the solution to the game is the Nash equilibrium where neither player can improve their loss unilaterally. This powerful framework can also be derived by minimizing a divergence between the model distribution and the true distribution (Nowozin et al., 2016; Arjovsky et al., 2017).
+
+Training GANs involves solving a minimax problem over the parameters of the generator and the discriminator which are usually parameterized as deep convolutional neural networks. Consequently, this minimax problem is notoriously hard to solve in practice. As a result, a plethora of loss functions, regularization and normalization schemes, coupled with neural architecture choices, have been proposed (Goodfellow et al., 2014; Salimans et al., 2016; Miyato et al., 2018; Gulrajani et al., 2017; Arjovsky et al., 2017; Mao et al., 2016).
+
+Our contributions. In this work we provide a thorough empirical analysis of these competing approaches, and help the researchers and practitioners navigate this space. We first define the GAN landscape – the set of loss functions, normalization and regularization schemes, and the most commonly used architectures. We explore this search space on several modern large-scale data sets by means of hyperparameter optimization, considering both “good” sets of hyperparameters reported in the literature, as well as ones obtained by Gaussian Process regression. By analyzing the impact of the loss function, we conclude that the non-saturating loss is sufficiently stable across data sets, architectures and hyperparameters. We then proceed to decompose the effect of various normalization and regularization schemes, as well as varying architectures. We show that both gradient penalty (Gulrajani et al., 2017) as well as spectral normalization (Miyato et al., 2018) are useful in the context of high-capacity architectures. Finally, we discuss some common pitfalls, reproducibility issues, and practical considerations. We provide reference implementations, including training and evaluation code on Github1 and provide pre-trained models on TensorFlow Hub.2
+
+# 2 THE GAN LANDSCAPE
+
+# 2.1 LOSS FUNCTIONS
+
+Let $P$ denote the target (true) distribution and $Q$ the model distribution. Goodfellow et al. (2014) suggest two loss functions: the minimax GAN and the non-saturating (NS) GAN. In the former the discriminator minimizes the negative log-likelihood for the binary classification task. In the latter the generator maximizes the probability of generated samples being real. In this work we consider the non-saturating loss as it is known to outperform the minimax variant. The corresponding loss functions are $\mathcal { L } _ { \mathrm { { D } } } = - \mathbb { E } _ { \boldsymbol { x } \sim P } [ \log ( D ( \boldsymbol { x } ) ) ] - \mathbb { E } _ { \hat { \boldsymbol { x } } \sim Q } [ \log ( 1 - D ( \boldsymbol { \hat { x } } ) ) ]$ and $\mathcal { L } _ { \mathrm { G } } = - \mathbb { E } _ { \hat { x } \sim Q } [ \bar { \log ( D ( \hat { x } ) ) } ]$ .
+
+In Wasserstein GAN (WGAN) (Arjovsky et al., 2017) the authors propose to consider the Wasserstein divergence instead of the original Jensen-Shannon (JS). In particular, under the optimal discriminator, minimizing the proposed value function with respect to the generator minimizes the Wasserstein distance between $P$ and $Q$ . The drawback is that one has to ensure a 1-Lipschitz discriminator due to exploited Kantorovich-Rubenstein duality. The corresponding loss functions are $\mathcal { L } _ { \mathrm { D } } ~ =$ $- \mathbb { E } _ { x \sim P } [ D ( x ) ] + \mathbb { E } _ { \hat { x } \sim Q } [ D ( \hat { x } ) ]$ and $\mathcal { L } _ { \mathrm { G } } = - \mathbb { E } _ { \hat { x } \sim Q } [ D ( \hat { x } ) ]$ .
+
+Finally, we consider the least-squares loss (LS) which corresponds to minimizing the Pearson $\chi ^ { 2 }$ divergence between $P$ and $Q$ (Mao et al., 2016). The intuition is that this loss function is smooth and saturates slower than the sigmoid cross-entropy loss of the JS formulation. The corresponding loss functions are $\mathcal { L } _ { \mathrm { D } } = - \mathbb { E } _ { x \sim P } \overline { { [ ( D ( x ) - 1 ) ^ { 2 } ] } } + \tilde { \mathbb { E } } _ { \hat { x } \sim Q } [ D ( \hat { x } ) ^ { 2 } ]$ and $\mathcal { L } _ { \mathrm { G } } = - \mathbb { E } _ { \hat { x } \sim Q } [ ( D ( \hat { x } ) { \bar { - } } 1 ) ^ { 2 } ]$ ].
+
+# 2.2 REGULARIZATION AND NORMALIZATION OF THE DISCRIMINATOR
+
+Gradient norm penalty. In the context of Wasserstein GANs this penalty can be interpreted as a soft penalty for the violation of 1-Lipschitzness (WGAN GP) (Gulrajani et al., 2017). Hereby, the gradient is evaluated on a linear interpolation between training points and generated samples as a proxy to the optimal coupling. The gradient penalty can also be evaluated around the data manifold which encourages the discriminator to be piece-wise linear in that region (Dragan) (Kodali et al., 2017). However, the gradient norm penalty can be considered purely as a regularizer for the discriminator and it was shown that it can improve the performance for other losses (Fedus et al., 2018). Furthermore, the penalty can be scaled by the “confidence” of the discriminator in the context of f-divergences (Roth et al., 2017). A drawback of gradient penalty (GP) regularization scheme is that it can depend on the model distribution $Q$ which changes during training. One drawback of Dragan is that it is unclear to which extent the Gaussian assumption for the manifold holds. Finally, computing the gradient norms implies a non-trivial running time penalty – essentially doubling the running time. We also investigate the impact of a regularizer ubiquitous in supervised learning – the $L _ { 2 }$ penalty on all the weights of the network.
+
+Discriminator normalization. Normalizing the discriminator can be useful from both the optimization perspective (more efficient gradient flow, a more stable optimization), as well as from the representation perspective – the representation richness of the layers in a neural network depends on the spectral structure of the corresponding weight matrices (Miyato et al., 2018).
+
+From the optimization point of view, several techniques have found their way into the GAN literature, namely batch normalization (BN) (Ioffe and Szegedy, 2015) and layer normalization (LN) (Ba et al., 2016). Batch normalization in the context of GANs was suggested by Denton et al. (2015) and further popularized by Radford et al. (2016). It normalizes the pre-activations of nodes in a layer to mean $\beta$ and standard deviation $\gamma$ , where both $\beta$ and $\gamma$ are parameters learned for each node in the layer. The normalization is done on the batch level and for each node separately. In contrast, with Layer normalization, all the hidden units in a layer share the same normalization terms $\beta$ and $\gamma$ , but different samples are normalized differently (Ba et al., 2016). Layer normalization was first applied in the context of GANs in Gulrajani et al. (2017).
+
+From the representation point of view, one has to consider the neural network as a composition of (possibly non-linear) mappings and analyze their spectral properties. In particular, for the discriminator to be a bounded linear operator it suffices to control the maximum singular value. This approach is followed in Miyato et al. (2018) where the authors suggest dividing each weight matrix, including the matrices representing convolutional kernels, by their spectral norm. Furthermore, the authors argue that a key advantage of spectral normalization over competing approaches is that it results in discriminators of higher rank.
+
+# 2.3 GENERATOR AND DISCRIMINATOR ARCHITECTURE
+
+We explore two classes of architectures in this study: deep convolutional generative adversarial networks (DCGAN) (Radford et al., 2016) and residual networks (ResNet) (He et al., 2016), both of which are ubiquitous in GAN research. Recently, Miyato et al. (2018) defined a variation of DCGAN, so called SNDCGAN. Apart from minor updates (cf. Section 4) the main difference to DCGAN is the use of an eight-layer discriminator network. The details of both networks are summarized in Table 3. The other architecture, ResNet19, is an architecture with five ResNet blocks in the generator and six ResNet blocks in the discriminator, that can operate on $1 2 8 \times 1 2 8$ images. We follow the ResNet setup from Miyato et al. (2018), with the small difference that we simplified the design of the discriminator. The detailed parameters of discriminator and generator are summarized in Table 4a and Table 4b. With this setup we were able to reproduce the current state of the art results. An ablation study on various ResNet modifications is available in the Appendix.
+
+# 2.4 EVALUATION METRICS
+
+We focus on several recently proposed metrics well suited to the image domain. For an in-depth overview of quantitative metrics we refer the reader to (Borji, 2018).
+
+Inception Score (IS). Proposed by Salimans et al. (2016), IS offers a way to quantitatively evaluate the quality of generated samples. Intuitively, the conditional label distribution of samples containing meaningful objects should have low entropy, and the variability of the samples should be high. which can be expressed as $\scriptstyle \mathtt { I S } = \exp ( \mathbb { E } _ { x \sim Q } [ d _ { K L } ^ { \sim } ( p ( y \mid x ) , p ( y ) ) ] )$ . The authors found that this score is well-correlated with scores from human annotators. Drawbacks include insensitivity to the prior distribution over labels and not being a proper distance.
+
+As an alternative Heusel et al. (2017) proposed the Frechet Inception Distance (FID). Samples from $P$ and $Q$ are first embedded into a feature space (a specific layer of InceptionNet). Then, assuming that the embedded data follows a multivariate Gaussian distribution, the mean and covariance are estimated. Finally, the Frechet distance between these two Gaussians is computed, i.e. ´
+
+$$
+\begin{array} { r } { \mathtt { F I D } = | | \mu _ { x } - \mu _ { y } | | _ { 2 } ^ { 2 } + \operatorname { T r } \big ( \Sigma _ { x } + \Sigma _ { y } - 2 \big ( \Sigma _ { x } \Sigma _ { y } \big ) ^ { \frac { 1 } { 2 } } \big ) , } \end{array}
+$$
+
+where $\left( \mu _ { x } , \Sigma _ { x } \right)$ , and $( \mu _ { y } , \Sigma _ { y } )$ are the mean and covariance of the embedded samples from $P$ and $Q$ , respectively. The authors argue that FID is consistent with human judgment and more robust to noise than IS. Furthermore, the score is sensitive to the visual quality of generated samples – introducing noise or artifacts in the generated samples will reduce the FID. In contrast to IS, FID can detect intra-class mode dropping, i.e. a model that generates only one image per class can score a perfect IS, but will suffer from have a high FID (Lucic et al., 2018). Binkowski et al. ´ (2018) argued that FID has no unbiased estimator and suggest Kernel Inception distance (KID) instead. In Appendix B we empirically compare KID to FID and observe that both metrics are very strongly correlated (Spearman rank-order correlation coefficient of 0.994 for LSUN-BEDROOM and 0.995 for CELEBA-HQ-128 datasets). As a result we focus on FID as it is likely to result in the same ranking.
+
+Multi-scale Structural Similarity for Image Quality (MS-SSIM) and Diversity. A critical issue in GANs are mode collapse and mode-dropping – failing to capture a mode, or low-diversity of generated samples from a given mode. The MS-SSIM score (Wang et al., 2003) is used for measuring the similarity of two images where higher MS-SSIM score indicates more similar images. Several recent works suggest using the average pairwise MS-SSIM score within a given class as a proxy for the diversity of generated samples (Odena et al., 2017; Fedus et al., 2018). The drawback of this approach is that we do not know the class corresponding to the generated sample, so it is usually applied on one-class data sets, such as CELEBA-HQ-128. In this work we use the same setup as in Fedus et al. (2018). In particular, given a batch size $b$ , we compute the average pairwise MS-SSIM score on 5 batches, of $5 \times b \times ( b - 1 ) / 2$ image pairs in total. We stress that the diversity should only be taken into account together with the FID and $I S$ metrics.
+
+Table 1: Hyperparameter ranges used in this study. The Cartesian product of the fixed values suffices to uncover the existing results. Gaussian Process optimization in the bandit setting (Srinivas et al., 2010) is used to select good hyperparameter settings from the specified ranges.   
+(a) Fixed values   
+
+<table><tr><td>PARAMETER</td><td>DISCRETE VALUE</td></tr><tr><td>Learning rate α</td><td>{0.0002,0.0001,0.001}</td></tr><tr><td>Reg. strength 入</td><td>{1,10}</td></tr><tr><td>(β1,β2,ndis)</td><td>{(0.5,0.900,5), (0.5,0.999,1), (0.5,0.999,5), (0.9,0.999,5)}</td></tr></table>
+
+(b) Gaussian Process regression ranges   
+
+<table><tr><td>PARAMETER</td><td>RANGE</td><td>LOG</td></tr><tr><td>Learning rate α</td><td>[10-5,10-2]</td><td>Yes</td></tr><tr><td>入 for L2</td><td>[10-4,101]</td><td>Yes</td></tr><tr><td>入 for non-L2</td><td>[10-1,102]</td><td>Yes</td></tr><tr><td>β1×β</td><td>[0,1] × [0,1]</td><td>No</td></tr></table>
+
+# 2.5 DATA SETS
+
+We consider three data sets, namely CIFAR10, CELEBA-HQ-128, and LSUN-BEDROOM. The LSUN-BEDROOM data set (Yu et al., 2015) contains slightly more than 3 million images3. We randomly partition the images into a train and test set whereby we use 30588 images as the test set. Secondly, we use the CELEBA-HQ data set of 30k images (Karras et al., 2018). We use the $1 2 8 \times 1 2 8 \times 3$ version obtained by running the code provided by the authors.4 We use 3000 examples as the test set and the remaining examples as the training set. Finally, we also include the CIFAR10 data set which contains 70K images $\left( 3 2 \mathbf { x } 3 2 \mathbf { x } 3 \right)$ , partitioned into 60000 training instances and 10000 testing instances. The baseline FID scores are 12.6 for CELEBA-HQ-128, 3.8 for LSUN-BEDROOM, and 5.19 for CIFAR10. Details on FID computation are presented in Section 4.
+
+# 2.6 EXPLORING THE GAN LANDSCAPE
+
+The search space for GANs is prohibitively expensive: exploring all combinations of all losses, normalization and regularization schemes, and architectures is outside of the practical realm. Instead, in this study we analyze several slices of this tensor for each data set. In particular, to ensure that we can reproduce existing results, we perform a study over the subset of this tensor on CIFAR10. We then proceed to analyze the performance of these models across CELEBA-HQ-128 and LSUN-BEDROOM. In Section 3.1 we fix everything but the loss. In Section 3.2 we fix everything but the regularization and normalization scheme. Finally, in Section 3.3 we fix everything but the architecture. This allows us to decouple some of these design choices and provide some insight on what matters most.
+
+As noted in Lucic et al. (2018), one major issue preventing further progress is the hyperparameter tuning – currently, the community has converged to a small set of parameter values which work on some data sets, and may completely fail on others. In this study we combine the best hyperparameter settings found in the literature (Miyato et al., 2018), and perform Gaussian Process regression in the bandit setting (Srinivas et al., 2010) to possibly uncover better hyperparameter settings. We then consider the top performing models and discuss the impact of the computational budget.
+
+We summarize the fixed hyperparameter settings in Table 1a which contains the “good” parameters reported in recent publications (Fedus et al., 2018; Miyato et al., 2018; Gulrajani et al., 2017). In particular, we consider the cross product of these parameters to obtain 24 hyperparameter settings to reduce the bias. Finally, to provide a fair comparison, we perform Gaussian Process optimization in the bandit setting (Srinivas et al., 2010) on the parameter ranges provided in Table 1b. We run 12 rounds (i.e. we communicate with the oracle 12 times) of the optimization, each with a batch of 10 hyperparameter sets selected based on the FID scores from the results of the previous iterations.
+
+![](images/f7632ddba45f2ade2676217c086988ad49718568456061ecaba4e597982b4dfe.jpg)  
+Figure 1: Impact of the loss function: FID distribution for top $5 \%$ models. The non-saturating (NS) loss is stable over both data sets. Gradient penalty and spectral normalization improve the sample quality. From the computational budget perspective (i.e. how many models one needs to train to reach a certain FID), both spectral normalization and gradient penalty perform better than the baseline, but the former is more efficient.
+
+As we explore the number of discriminator updates per generator update (1 or 5), this leads to an additional 240 hyperparameter settings which in some cases outperform the previously known hyperparameter settings. Batch size is set to 64 for all the experiments. We use a fixed the number of discriminator update steps of 100K for LSUN-BEDROOM data set and CELEBA-HQ-128 data set, and 200K for CIFAR10 data set. We apply the Adam optimizer (Kingma and Ba, 2015).
+
+# 3 RESULTS AND DISCUSSION
+
+Given that there are 4 major components (loss, architecture, regularization, normalization) to analyze for each data set, it is infeasible to explore the whole landscape. Hence, we opt for a more pragmatic solution – we keep some dimensions fixed, and vary the others. For each experiment we highlight three aspects: (1) FID distribution of the top $5 \%$ of the trained models, (2) the corresponding sample diversity score, and (3) the tradeoff between the computational budget (i.e. number of models to train) and model quality in terms of FID. Each model was retrained 5 times with a different random seed and we report the median score. The variance for models obtained by Gaussian Process regression is handled implicitly so we train each model once.
+
+# 3.1 IMPACT OF THE LOSS FUNCTION
+
+Here the loss is either the non-saturating loss (NS) (Goodfellow et al., 2014), the least-squares loss (LS) (Mao et al., 2016), or the Wasserstein loss (WGAN) (Arjovsky et al., 2017). We use the ResNet19 with generator and discriminator architectures detailed in Table 4a. We consider the most prominent normalization and regularization approaches: gradient penalty (Gulrajani et al., 2017), and spectral normalization (Miyato et al., 2018). Both studies were performed on CELEBA-HQ-128 and LSUN-BEDROOM with hyperparameter settings shown in Table 1a.
+
+The results are presented in Figure 1. We observe that the non-saturating loss is stable over both data sets. Spectral normalization improves the quality of the model on both data sets. Similarly, the gradient penalty can help improve the quality of the model, but finding a good regularization tradeoff is non-trivial and requires a high computational budget. Models using the GP penalty benefit from 5:1 ratio of discriminator to generator updates as suggested by (Gulrajani et al., 2017). We also performed a study on hinge loss (Miyato et al., 2018) and present it in the Appendix.
+
+![](images/82e848101388335cba5420ecc90eab32f9659adccd2f642efa36a986d2c1d407.jpg)  
+Figure 2: Impact of regularization and normalization: FID distribution for top $5 \%$ models. Both gradient penalty (GP) and spectral normalization (SN) outperform the baseline and should be considered, while former being more computationally expensive. Unfortunately none fully address the stability issues.
+
+# 3.2 IMPACT OF REGULARIZATION AND NORMALIZATION
+
+The goal of this study is to compare the relative performance of various regularization and normalization methods presented in the literature. To this end, and based on the loss study, we fix the loss to non-saturating loss (Goodfellow et al., 2014). We use the ResNet19 with generator and discriminator architectures described in Table 4a. Finally, we consider batch normalization (BN) (Ioffe and Szegedy, 2015), layer normalization (LN) (Ba et al., 2016), spectral normalization (SN), gradient penalty (GP) (Gulrajani et al., 2017), dragan penalty (DR) (Kodali et al., 2017), or $L _ { 2 }$ regularization. We consider both CELEBA-HQ-128 and LSUN-BEDROOM with the hyperparameter settings shown in Table 1a and Table 1b.
+
+The results are presented in Figure 2. We observe that adding batch norm to the discriminator hurts the performance. Secondly, gradient penalty can help, but it doesn’t stabilize the training. In fact, it is non-trivial to strike a balance of the loss and regularization strength. Spectral normalization helps improve the model quality and is more computationally efficient than gradient penalty. This is consistent with recent results in Zhang et al. (2018). Similarly to the loss study, models using GP penalty benefit from 5:1 ratio of discriminator to generator updates. Furthermore, in a separate ablation study we observed that running the optimization procedure for an additional 100K steps is likely to increase the performance of the models with GP penalty.
+
+Impact of Simultaneous Regularization and Normalization. Given the folklore that the Lipschitz constant of the discriminator is critical for the performance, one may expect simultaneous regularization and normalization could improve model quality. To quantify this effect, we fix the loss to non-saturating loss (Goodfellow et al., 2014), use the Resnet19 architecture (as above), and combine several normalization and regularization schemes, with hyperparameter settings shown in Table 1a coupled with 24 randomly selected parameters. The results are presented in Figure 3. We observe that one may benefit from additional regularization and normalization. However, a lot of computational effort has to be invested for somewhat marginal gains in FID. Nevertheless, given enough computational budget we advocate simultaneous regularization and normalization – spectral normalization and layer normalization seem to perform well in practice.
+
+![](images/46e4df44d5fbb143416866b4220f7afea497ffb5bb5691af926e9d009ed5d8ec.jpg)  
+Figure 3: Impact of simultaneous normalization and regularization: FID distribution for top $5 \%$ models. Gradient penalty coupled with spectral normalization (SN) or layer normalization (LN) strongly improves the performance over the baseline.
+
+# 3.3 IMPACT OF GENERATOR AND DISCRIMINATOR ARCHITECTURES
+
+An interesting practical question is whether our findings also hold for a different model capacity. To this end, we also perform a study on SNDCGAN from Miyato et al. (2018). We consider the non-saturating GAN loss, gradient penalty and spectral normalization. While for smaller architectures regularization is not essential (Lucic et al., 2018), the regularization and normalization effects might become more relevant due to deeper architectures and optimization considerations.
+
+![](images/3e965e3c9706e0a9c32f50c8a17e42a830c7fba8c8e37ec83f2e9451c076d310.jpg)  
+Figure 4: Impact of the neural architectures: FID distribution for top $5 \%$ models. Both spectral normalization and gradient penalty can help improve upon the non-regularized baseline.
+
+The results are presented in Figure 4. We observe that both architectures achieve comparable results and benefit from regularization and normalization. Spectral normalization strongly outperforms the baseline for both architectures.
+
+# 4 COMMON PITFALLS
+
+In this section we focus on several pitfalls we encountered while trying to reproduce existing results and provide a fairly and accurate comparison.
+
+Metrics. There already seems to be a divergence in how the FID score is computed: (1) Some authors report the score on training data, yielding a FID between 50k training and $5 0 \mathrm { k }$ generated samples (Unterthiner et al., 2018). Some opt to report the FID based on 10k test samples and $5 \mathrm { k }$ generated samples and use a custom implementation (Miyato et al., 2018). Finally, Lucic et al. (2018) report the score with respect to the test data, in particular FID between 10k test samples, and 10k generated samples. The subtle differences will result in a mismatch between the reported FIDs, in some cases of more than $1 0 \%$ . We argue that FID should be computed with respect to the test data set as and use 10k test samples and 10k generated samples on CIFAR10 and LSUN-BEDROOM, and 3k vs 3k on CELEBA-HQ-128 as in in Lucic et al. (2018). Similarly, there are several ways to compute a diversity score using MS-SSIM and we follow the approach from Fedus et al. (2018). We provide the implementation details in Section G of the Appendix.
+
+Details of neural architectures. Even in popular architectures, like ResNet, there is still a number of design decision one needs to make, that are often omitted from the reported results. Those include the exact design of the ResNet cell (order of layers, when is ReLu applied, when to upsample and downsample, how many filters to use). Some of these differences might lead to potentially unfair comparison. As a result, we suggest to use the architectures presented within this work as a solid baseline. An ablation study on various ResNet modifications is available in the Appendix.
+
+Data sets. A common issue is related to data set processing – does LSUN-BEDROOM always correspond to the same data set? In most cases the precise algorithm for upscaling or cropping is not clear which introduces inconsistencies between results on the “same” data set.
+
+Implementation details and non-determinism. One major issue is the mismatch between the algorithm presented in a paper and the code provided online. We are aware that there is an embarrassingly large gap between a good implementation and a bad implementation of a given model. Hence, when no code is available, one is forced to guess which modifications were done. Another particularly tricky issue is removing randomness from the training process. After one fixes the data ordering and the initial weights, obtaining the same score by training the same model twice is non-trivial due to randomness present in certain GPU operations (Chetlur et al., 2014). Disabling the optimizations causing the non-determinism often results in an order of magnitude running time penalty.
+
+While each of these issues taken in isolation seems minor, they compound to create a mist which introduces friction in practical applications and the research process (Sculley et al., 2018).
+
+# 5 RELATED WORK
+
+A recent large-scale study on GANs and Variational Autoencoders was presented in Lucic et al. (2018). The authors consider several loss functions and regularizers, and study the effect of the loss function on the FID score, with low-to-medium complexity data sets (MNIST, CIFAR10, CELEBA), and a single (InfoGAN style) architecture. In this limited setting, the authors found that there is no statistically significant difference between recently introduced models and the original non-saturating GAN. A study of the effects of gradient-norm regularization in GANs was recently presented in Fedus et al. (2018). The authors posit that the gradient penalty can also be applied to the non-saturating GAN, and that, to a limited extent, it reduces the sensitivity to hyperparameter selection. In a recent work on spectral normalization, the authors perform a small study of the competing regularization and normalization approaches (Miyato et al., 2018). We are happy to report that we could reproduce these results and we present them in the Appendix.
+
+Inspired by these works and building on the available open-source code from Lucic et al. (2018), we take one additional step in all dimensions considered therein: more complex neural architectures, more complex data sets, and more involved regularization and normalization schemes.
+
+# 6 CONCLUSION
+
+In this work we study the GAN landscape: losses, regularization and normalization schemes, and neural architectures, and their impact on the on the quality of generated samples which we assess by recently introduced quantitative metrics. Our fair and thorough empirical evaluation suggests that one should consider non-saturating GAN loss and spectral normalization as default choices when applying GANs to a new data set. Given additional computational budget, we suggest adding the gradient penalty from Gulrajani et al. (2017) and train the model until convergence. Furthermore, additional marginal gains can be obtained by combining normalization and regularization empirically confirming the importance of the Lipschitz constant of the discriminator. Furthermore, both types of architectures proposed up-to this point perform reasonably well. A separate ablation study uncovered that most of the tricks applied in the ResNet style architectures lead to marginal changes in the quality and should be avoided due to the high computational cost. As a result of this large-scale study we identify the common pitfalls standing in the way of accurate and fair comparison and propose concrete actions to demystify the future results – issues with metrics, data set preprocessing, non-determinism, and missing implementation details are particularly striking. We hope that this work, together with the open-sourced reference implementations and trained models, will serve as a solid baseline for future GAN research.
+
+# REFERENCES
+
+Eirikur Agustsson, Michael Tschannen, Fabian Mentzer, Radu Timofte, and Luc Van Gool. Generative adversarial networks for extreme learned image compression. CoRR, abs/1804.02958, 2018.
+
+Mart´ın Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. In ´ International Conference on Machine Learning (ICML), 2017.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Mikołaj Binkowski, Dougal J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD GANs. In ´ International Conference on Learning Representations (ICLR), 2018.
+
+Ali Borji. Pros and cons of GAN evaluation measures. arXiv preprint arXiv:1802.03446, 2018.
+
+Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. arXiv preprint arXiv:1410.0759, 2014.
+
+Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in Neural Information Processing Systems (NIPS), 2015.
+
+William Fedus, Mihaela Rosca, Balaji Lakshminarayanan, Andrew M Dai, Shakir Mohamed, and Ian Goodfellow. Many paths to equilibrium: Gans do not need to decrease a divergence at every step. In International Conference on Learning Representations (ICLR), 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 (NIPS), 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of Wasserstein GANs. Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and Sepp Hochre-¨ iter. GANs trained by a two time-scale update rule converge to a Nash equilibrium. Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. International Conference on Learning Representations (ICLR), 2018.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR), 2015.
+
+Naveen Kodali, Jacob Abernethy, James Hays, and Zsolt Kira. On convergence and stability of GANs. arXiv preprint arXiv:1705.07215, 2017.
+
+Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are GANs created equal? A large-scale study. Advances in Neural Information Processing Systems (NIPS), 2018.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. arXiv preprint ArXiv:1611.04076, 2016.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations (ICLR), 2018.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In International Conference on Machine Learning (ICML), 2017.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. International Conference on Learning Representations (ICLR), 2016.
+
+Kevin Roth, Aurelien Lucchi, Sebastian Nowozin, and Thomas Hofmann. Stabilizing training of generative adversarial networks through regularization. In Advances in Neural Information Processing Systems, 2017.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+D. Sculley, Jasper Snoek, Alex Wiltschko, and Ali Rahimi. Winner’s curse? On pace, progress, and empirical rigor, 2018.
+
+Niranjan Srinivas, Andreas Krause, Sham Kakade, and Matthias W. Seeger. Gaussian process optimization in the bandit setting: No regret and experimental design. In International Conference on Machine Learning (ICML), 2010.
+
+Michael Tschannen, Eirikur Agustsson, and Mario Lucic. Deep generative models for distribution-preserving lossy compression. Advances in Neural Information Processing Systems (NIPS), 2018.
+
+Thomas Unterthiner, Bernhard Nessler, Calvin Seward, Gnter Klambauer, Martin Heusel, Hubert Ramsauer, and Sepp Hochreiter. Coulomb GANs: Provably optimal nash equilibria via potential fields. In International Conference on Learning Representations (ICLR), 2018.
+
+Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems and Computers, 2003.
+
+Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365, 2015.
+
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018.
+
+# A FID AND INCEPTION SCORES ON CIFAR10
+
+We present an empirical study with SNDCGAN and ResNet CIFAR architectures on CIFAR10 in figure 5 and figure 6. In addition to Section 3.1, we evaluate one more kind of loss on CIFAR10. Here HG, NS and WGAN stand for hinge loss, non saturating loss and Wasserstein loss respectively. We observe that hinge loss performs very similar to non-saturating loss.
+
+![](images/c164b1f15578e4a9ef02160d0cfbbfa32f06c4db8cef2e901de85c271df39446.jpg)  
+Figure 5: An empirical study with SNDCGAN and ResNet cifar architectures on CIFAR10. We recover the state of the art results recently reported in Miyato et al. (2018).
+
+![](images/9336b9938cfebbfb0ad26108c3d376665c6fce35dadf469e8a26634157b3acfa.jpg)  
+Figure 6: We show the Inception Score for each model within our study which corresponds to recently reported results (Miyato et al., 2018).
+
+# B COMPARISON OF FID AND KID METRICS
+
+The KID metric introduced by Binkowski et al. ´ (2018) is an alternative to FID. We use models from our Regularization and Normalization study (see Section 3.2) to compare both metrics. Here, by model we denote everything that needs to be specified for the training – including all hyper-parameters, like learning rate, $\lambda$ , Adam’s $\beta$ , etc. The Spearman rank-order correlation coefficient between KID and FID scores is approximately 0.994 for LSUN-BEDROOM and 0.995 for CELEBA-HQ-128 datasets.
+
+To evaluate a practical setting of selecting several best models, we compare the intersection between the set of “best $K$ models by FID” and the set of “best $K$ models by KID” for $\bar { K } \in { 5 , 1 0 , 2 0 , 5 0 , 1 0 0 }$ . The results are summarized in Table 2.
+
+This experiment suggests that FID and KID metrics are very strongly correlated, and for the practical applications one can choose either of them. Also, the conclusions from our studies based on FID should transfer to studies based on KID.
+
+Table 2: Intersection between set of top $K$ experiments selected by FID and KID metrics.   
+
+<table><tr><td></td><td>LSUN-BEDROOM CELEBA-HQ-128</td></tr><tr><td>K=5 4/5</td><td>2/5</td></tr><tr><td>K=10</td><td>9/10 8/10</td></tr><tr><td>K=20</td><td>18/20 15/20</td></tr><tr><td>K=50 49/50</td><td>46/50</td></tr><tr><td>K=100</td><td>95/100 98/100</td></tr></table>
+
+# C ARCHITECTURES
+
+# C.1 SNDCGAN
+
+We used the same architecture as Miyato et al. (2018), with the parameters copied from the GitHub page5. In Table 3a and Table 3b, we describe the operations in layer column with order. Kernel size is described in format [f ilter h, f ilter $_ - w$ , stride], input shape is $h \times w$ and output shape is $h \times w \times c h a n n e l s$ . The slopes of all lReLU functions are set to 0.1. The input shape $h \times w$ is $1 2 8 \times 1 2 8$ for CELEBA-HQ-128 and LSUN-BEDROOM, $3 2 \times 3 2$ for CIFAR10.
+
+Table 3: SNDCGAN architecture.   
+  
+
+<table><tr><td colspan="2">(a) SNDCGANdiscriminator</td></tr><tr><td>LAYER KERNEL</td><td>OUTPUT</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h×w×64</td></tr><tr><td>Conv, IReLU [4,4,2]</td><td>h/2 × w/2 × 128</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/2 × w/2 × 128</td></tr><tr><td>Conv, lReLU [4,4,2]</td><td>h/4 × w/4× 256</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/4 × w/4 × 256</td></tr><tr><td>Conv, IReLU [4,4,2]</td><td>h/8×w/8× 512</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/8×w/8× 512</td></tr><tr><td>Linear 1</td><td>1</td></tr></table>
+
+(b) SNDCGAN generator  
+
+<table><tr><td>LAYER</td><td>KERNEL OUTPUT</td></tr><tr><td>2 1</td><td>128</td></tr><tr><td>Linear, BN, ReLU</td><td>h/8×w/8× 512 1</td></tr><tr><td>Deconv, BN, ReLU [4,4,2]</td><td>h/4 ×w/4 × 256</td></tr><tr><td>Deconv,BN,ReLU</td><td>[4,4,2] h/2 × w/2 × 128</td></tr><tr><td>Deconv, BN, ReLU</td><td>[4,4,2] h×w×64</td></tr><tr><td>Deconv, Tanh [3,3,1]</td><td>h×w×3</td></tr></table>
+
+# C.2 RESNET ARCHITECTURE
+
+The ResNet19 architecture is described in Table 4. RS column stands for the resample of the residual block, with downscale(D)/upscale(U)/none(-) setting. MP stands for mean pooling and BN for batch normalization. ResBlock is defined in Table 5. The addition layer merges two paths by adding them. The first path is a shortcut layer with exactly one convolution operation, while the second path consists of two convolution operations. The downscale layer and upscale layer are marked in Table 5. We used average pool with kernel [2, 2, 2] for downscale, after the convolution operation. We used unpool from https://github.com/tensorflow/ tensorflow/issues/2169 for upscale, before convolution operation. $h$ and $w$ are the input shape to the ResNet block, output shape depends on the RS parameter. $c _ { i }$ and $c _ { o }$ are the input channels and output channels for a ResNet block. Table 6 described the ResNet CIFAR architecture we used in Figure 5 for reproducing the existing results. Note that RS is set to none for third ResBlock and fourth ResBlock in discriminator. In this case, we used the same ResNet block defined in Table 5 without resampling.
+
+Table 4: ResNet 19 architecture corresponding to “resnet small” in https://github.com/ pfnet-research/sngan_projection.   
+(a) ResNet19 discriminator   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS OUTPUT</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>64 × 64× 64</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>32 × 32 ×128</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>16 ×16× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>8×8× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>4 ×4 × 512</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>2 ×2× 512</td></tr><tr><td>ReLU, MP</td><td>-</td><td>512</td></tr><tr><td>Linear</td><td>- -</td><td>1</td></tr></table>
+
+(b) ResNet19 generator   
+Table 5: ResNet block definition.   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>2</td><td></td><td>1</td><td>128</td></tr><tr><td>Linear</td><td>-</td><td>1</td><td>4×4× 512</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>8×8×512</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>16 × 16× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>32 × 32 × 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>64 × 64 × 128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>128 × 128 × 64</td></tr><tr><td>BN,ReLU</td><td>1</td><td>1</td><td>128 × 128 × 64</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>1</td><td>128 × 128× 3</td></tr><tr><td>Sigmoid</td><td>-</td><td>-</td><td>128 × 128 × 3</td></tr></table>
+
+(a) ResBlock discriminator   
+Table 6: ResNet CIFAR architecture.   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>Shortcut</td><td>[3,3,1]</td><td>D</td><td>h/2 × w/2 × Co</td></tr><tr><td>BN,ReLU</td><td>1</td><td>1</td><td>hxwXCi</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>-</td><td>h×w×co</td></tr><tr><td>BN,ReLU</td><td>=</td><td>=</td><td>h×w×co</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>D</td><td>h/2 × w/2 ×Co</td></tr><tr><td>Addition</td><td>-</td><td>-</td><td>h/2 × w/2 × Co</td></tr></table>
+
+(b) ResBlock generator   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>Shortcut</td><td>[3,3,1]</td><td>U</td><td>2h× 2w XCo</td></tr><tr><td>BN, ReLU</td><td>1</td><td>-</td><td>h×wXCi</td></tr><tr><td rowspan="3">Conv BN, ReLU</td><td>[3,3,1]</td><td>U</td><td>2h ×2w×Co</td></tr><tr><td>-</td><td>1</td><td>2h × 2w ×Co</td></tr><tr><td>[3,3,1]</td><td>1</td><td>2h ×2w×Co</td></tr><tr><td>Conv Addition</td><td>-</td><td>-</td><td>2h × 2w X Co</td></tr></table>
+
+(a) ResNet CIFAR discriminator   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS OUTPUT</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>D 16 × 16 × 128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>D 8×8×128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>8×8×128 -</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>- 8×8×128</td></tr><tr><td>ReLU, MP</td><td></td><td>128 -</td></tr><tr><td>Linear</td><td>-</td><td>- 1</td></tr></table>
+
+(b) ResNet CIFAR generator   
+
+<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>2</td><td></td><td>-</td><td>128</td></tr><tr><td>Linear</td><td>-</td><td>-</td><td>4×4×256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>8×8× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>16 × 16 × 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>32 × 32 × 256</td></tr><tr><td>BN, ReLU</td><td>1</td><td>1</td><td>32 × 32× 256</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>-</td><td>32 × 32 × 3</td></tr><tr><td>Sigmoid</td><td>1</td><td>-</td><td>32 × 32 × 3</td></tr></table>
+
+# D RESNET ARCHITECTURE ABLATION STUDY
+
+We have noticed six minor differences on Resnet architecture comparing to implementation from https: //github.com/pfnet-research/chainer-gan-lib/blob/master/common/net.py (Miyato et al., 2018). We did ablation study to verify the impact of these differences. Figure 7 shows the impact of the ablation study, with details described as following.
+
+• DEFAULT: ResNet CIFAR architecture with spectral normalization and non-saturating GAN loss.   
+• SKIP: Use input as output for the shortcut connection in the discriminator ResBlock. By default it was a conv layer with 3x3 kernel.   
+CIN: Use $c _ { i }$ for the discriminator ResBlock hidden layer output channels. By default it was $c _ { o }$ in our setup, while Miyato et al. (2018) used $c _ { o }$ for first ResBlock and $c _ { i }$ for the rest. OPT: Use an optimized setup for the first discriminator ResBlock, which includes: (1) no ReLU, (2) a conv layer for the shortcut connections, (3) use $c _ { o }$ instead of $c _ { i }$ in ResBlock.   
+CIN OPT: Use CIN and OPT together. It means the first ResBlock is optimized while the remaining ResBlocks use $c _ { i }$ for the hidden output channels.   
+• SUM: Use reduce sum for the discriminator output. By default it was reduce mean.   
+• TAN: Use tanh for the generator output, as well as range [-1, 1] for discriminator input. By default it was sigmoid and discriminator input range [0, 1].   
+EPS: Use a bigger epsilon $\mathrm { 2 e - 5 }$ for generator batch normalization. By default it was 1e − 5 in TensorFlow.   
+• ALL: Apply all the above differences together.
+
+In the ablation study, the CIN experiment obtained the worst FID score. Combining with OPT, the CIN results were improved to the same level as the others which is reasonable because the first block has three input channels, which becomes a bottleneck for the optimization. Hence, using OPT and CIN together performs as well as the others. Overall, the impact of these differences are minor according to the study on CIFAR10.
+
+![](images/915843060e097817e89e5ef818f9f0c36cdf124f39cb363d94c6249fa26e25de.jpg)  
+Figure 7: Ablation study of ResNet architecture differences. The experiment codes are described in Section D.
+
+# E RECOMMENDED HYPERPARAMETER SETTINGS
+
+To make the future GAN training simpler, we propose a set of best parameters for three setups: (1) Best parameters without any regularizer. (2) Best parameters with only one regularizer. (3) Best parameters with at most two regularizers. Table 7, Table 8 and Table 9 summarize the top 2 parameters for SNDCGAN architecture, ResNet19 architecture and ResNet CIFAR architecture, respectively. Models are ranked according to the median FID score of five different random seeds with fixed hyper-parameters in Table 1a. Note that ranking models according to the best FID score of different seeds will achieve better but unstable result. Gaussian Process optimization hyper-parameters are not included in this table. For ResNet19 architecture with at most two regularizers, we have run it only once due to computational overhead. To show the model stability, we listed the best FID score out of five seeds from the same parameters in column best. Spectral normalization is clearly outperforms the other normalizers on SNDCGAN and ResNet CIFAR architectures, while on ResNet19 both layer normalization and spectral normalization work well.
+
+To visualize the FID score on each data set, Figure 8, Figure 9 and Figure 10 show the generated examples by GANs. We select the examples from the best FID run, and then increase the FID score for two more plots.
+
+Table 7: SNDCGAN parameters   
+
+<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β1</td><td>β</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CIFAR10</td><td>29.75</td><td>28.66</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>1</td></tr><tr><td>CIFAR10</td><td>36.12</td><td>33.23</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>=</td></tr><tr><td>CELEBA-HQ-128</td><td>66.42</td><td>63.13</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>CELEBA-HQ-128</td><td>67.39</td><td>64.59</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>=</td></tr><tr><td>LSUN-BEDROOM</td><td>180.36</td><td>160.12</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>LSUN-BEDROOM</td><td>188.99</td><td>162.00</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>CIFAR10</td><td>26.66</td><td>25.27</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>CIFAR10</td><td>27.32</td><td>26.97</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>31.14</td><td>29.05</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>33.52</td><td>31.92</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>63.46</td><td>58.13</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>74.66</td><td>59.94</td><td>1.000</td><td>0.500</td><td>0.999</td><td>1</td><td>-</td><td>SN</td></tr><tr><td>CIFAR10</td><td>26.23</td><td>26.01</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN+GP</td></tr><tr><td>CIFAR10</td><td>26.66</td><td>25.27</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>31.13</td><td>30.80</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>GP</td></tr><tr><td>CELEBA-HQ-128</td><td>31.14</td><td>29.05</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>63.46</td><td>58.13</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>66.58</td><td>65.75</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>GP</td></tr></table>
+
+Table 8: ResNet19 parameters   
+
+<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β</td><td>阳</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CELEBA-HQ-128</td><td>43.73</td><td>39.10</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td></td><td></td></tr><tr><td>CELEBA-HQ-128</td><td>43.77</td><td>39.60</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>-</td></tr><tr><td>LSUN-BEDROOM</td><td>160.97</td><td>119.58</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td></td><td></td></tr><tr><td>LSUN-BEDROOM</td><td>161.70</td><td>125.55</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>=</td><td>1</td></tr><tr><td>CELEBA-HQ-128</td><td>32.46</td><td>28.52</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>LN</td></tr><tr><td>CELEBA-HQ-128</td><td>40.58</td><td>36.37</td><td>0.200</td><td>0.500</td><td>0.900</td><td>1</td><td></td><td>LN</td></tr><tr><td>LSUN-BEDROOM</td><td>70.30</td><td>48.88</td><td>1.000</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>73.84</td><td>60.54</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>-</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>29.13</td><td>=</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>LN+DR</td></tr><tr><td>CELEBA-HQ-128</td><td>29.65</td><td></td><td>0.200</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>GP</td></tr><tr><td>LSUN-BEDROOM</td><td>55.72</td><td></td><td>0.200</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>LN+GP</td></tr><tr><td>LSUN-BEDROOM</td><td>57.81</td><td></td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>SN+GP</td></tr></table>
+
+# F WHICH PARAMETERS REALLY MATTER?
+
+For each architecture and hyper-parameter we estimate its impact on the final FID. Figure 11 presents heatmaps for hyperparameters, namely the learning rate, $\beta _ { 1 }$ , $\beta _ { 2 }$ , $n _ { d i s c }$ , and $\lambda$ for each combination of neural architecture and data set.
+
+# G VARIATIONS OF MS-SSIM
+
+We used the MS-SSIM scorer from TensorFlow with default power factors (Wang et al., 2003). Note that the default filter size for each scale layer is 11, the minimum image edge is $1 1 \times 2 ^ { 4 } = 1 7 6$ . To adapt it to CELEBA-HQ-128 data set with size $1 2 8 \times 1 2 8$ , we used the minimum of filter size 11 and image size in last scale layer to allow the computation followed the previous work (Fedus et al., 2018).
+
+Table 9: ResNet CIFAR parameters   
+
+<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β1</td><td>阳</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CIFAR10</td><td>31.40</td><td>28.12</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>=</td></tr><tr><td>CIFAR10</td><td>33.79</td><td>30.08</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>1</td></tr><tr><td>CIFAR10</td><td>23.57</td><td>22.91</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>SN</td></tr><tr><td>CIFAR10</td><td>25.50</td><td>24.21</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td>1</td><td>SN</td></tr><tr><td>CIFAR10</td><td>22.98</td><td>22.73</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN+GP</td></tr><tr><td>CIFAR10</td><td>23.57</td><td>22.91</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>-</td><td>SN</td></tr></table>
+
+![](images/8c414c042d882f1159a23063a0813130967a1b2a1edd717e9194cf65a2038b5d.jpg)  
+Figure 8: Examples generated by GANs on CELEBA-HQ-128 data set.
+
+![](images/786ca8fc171e60cd0ce2ba0004d5703869c528cf8d62a05307aaaa0a46d3dac5.jpg)  
+Figure 9: Examples generated by GANs on LSUN-BEDROOM data set.
+
+![](images/f1aa1099a3ce5eda2019dddd846b6c2bcea9f181181c9afb1322704faf348863.jpg)  
+Figure 10: Examples generated by GANs on CIFAR10 data set.
+
+![](images/d088858e2c8a8cdce82899931934b317604f9bbc30cf7186dc9ab1f5de9f6026.jpg)  
+(a) FID score of SNDCGAN on CIFAR10
+
+![](images/7a4b30b761160941966aad9cf0ab6d3e235aa2b161986758303f170b1a6c47ad.jpg)
+
+![](images/6fdffed4172209843481fb9fb7c89d573d4d072037af4106b0d06c88c8ffef4a.jpg)  
+(b) FID score of SNDCGAN on CELEBA-HQ-128
+
+![](images/caca60a47d429ab4c4922f440ad3bcacb75f73720679a37c1f0fc45fed5e22fe.jpg)  
+(c) FID score of SNDCGAN on LSUN-BEDROOM
+
+![](images/ab454109195ada56fe60611674239d53e1ad36fe16717cd09a8e2e4b60b42140.jpg)  
+(d) FID score of ResNet CIFAR on CIFAR10
+
+![](images/ccd750f16de1b8efe3bdfea4b323d33e40ae824119fbb2a87ae4ec00eee859d8.jpg)  
+(e) FID score of ResNet19 on CELEBA-HQ-128   
+Figure 11: Heat plots for hyper-parameters on each architecture and dataset combination.

parse/train/rkGG6s0qKQ/rkGG6s0qKQ_content_list.json

@@ -0,0 +1,1786 @@
+[
+    {
+        "type": "text",
+        "text": "THE GAN LANDSCAPE: LOSSES, ARCHITECTURES, REGULARIZATION, AND NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            733,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks (GANs) are a class of deep generative models which aim to learn a target distribution in an unsupervised fashion. While they were successfully applied to many problems, training a GAN is a notoriously challenging task and requires a significant amount of hyperparameter tuning, neural architecture engineering, and a non-trivial amount of “tricks”. The success in many practical applications coupled with the lack of a measure to quantify the failure modes of GANs resulted in a plethora of proposed losses, regularization and normalization schemes, and neural architectures. In this work we take a sober view of the current state of GANs from a practical perspective. We reproduce the current state of the art and go beyond fairly exploring the GAN landscape. We discuss common pitfalls and reproducibility issues, open-source our code on Github, and provide pre-trained models on TensorFlow Hub. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            336,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep generative models are a powerful class of unsupervised machine learning models. The power of these models was recently harnessed in a variety of applications, including image generation, learned compression, and domain transfer (Isola et al., 2017; Radford et al., 2016; Agustsson et al., 2018; Tschannen et al., 2018). Generative adversarial networks (Goodfellow et al., 2014) are one of the main approaches to learning such models in a fully unsupervised fashion. The GAN framework can be viewed as a two-player game where the first player, the generator, is learning to transform some simple input distribution (usually a standard multivariate Normal or uniform) to a distribution on the space of images, such that the second player, the discriminator, cannot tell whether the samples belong to the true distribution or were synthesized. Both players aim to minimize their own loss and the solution to the game is the Nash equilibrium where neither player can improve their loss unilaterally. This powerful framework can also be derived by minimizing a divergence between the model distribution and the true distribution (Nowozin et al., 2016; Arjovsky et al., 2017). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training GANs involves solving a minimax problem over the parameters of the generator and the discriminator which are usually parameterized as deep convolutional neural networks. Consequently, this minimax problem is notoriously hard to solve in practice. As a result, a plethora of loss functions, regularization and normalization schemes, coupled with neural architecture choices, have been proposed (Goodfellow et al., 2014; Salimans et al., 2016; Miyato et al., 2018; Gulrajani et al., 2017; Arjovsky et al., 2017; Mao et al., 2016). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our contributions. In this work we provide a thorough empirical analysis of these competing approaches, and help the researchers and practitioners navigate this space. We first define the GAN landscape – the set of loss functions, normalization and regularization schemes, and the most commonly used architectures. We explore this search space on several modern large-scale data sets by means of hyperparameter optimization, considering both “good” sets of hyperparameters reported in the literature, as well as ones obtained by Gaussian Process regression. By analyzing the impact of the loss function, we conclude that the non-saturating loss is sufficiently stable across data sets, architectures and hyperparameters. We then proceed to decompose the effect of various normalization and regularization schemes, as well as varying architectures. We show that both gradient penalty (Gulrajani et al., 2017) as well as spectral normalization (Miyato et al., 2018) are useful in the context of high-capacity architectures. Finally, we discuss some common pitfalls, reproducibility issues, and practical considerations. We provide reference implementations, including training and evaluation code on Github1 and provide pre-trained models on TensorFlow Hub.2 ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE GAN LANDSCAPE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            169,
+            400,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LOSS FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            203,
+            338,
+            218
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $P$ denote the target (true) distribution and $Q$ the model distribution. Goodfellow et al. (2014) suggest two loss functions: the minimax GAN and the non-saturating (NS) GAN. In the former the discriminator minimizes the negative log-likelihood for the binary classification task. In the latter the generator maximizes the probability of generated samples being real. In this work we consider the non-saturating loss as it is known to outperform the minimax variant. The corresponding loss functions are $\\mathcal { L } _ { \\mathrm { { D } } } = - \\mathbb { E } _ { \\boldsymbol { x } \\sim P } [ \\log ( D ( \\boldsymbol { x } ) ) ] - \\mathbb { E } _ { \\hat { \\boldsymbol { x } } \\sim Q } [ \\log ( 1 - D ( \\boldsymbol { \\hat { x } } ) ) ]$ and $\\mathcal { L } _ { \\mathrm { G } } = - \\mathbb { E } _ { \\hat { x } \\sim Q } [ \\bar { \\log ( D ( \\hat { x } ) ) } ]$ . ",
+        "bbox": [
+            174,
+            231,
+            825,
+            315
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Wasserstein GAN (WGAN) (Arjovsky et al., 2017) the authors propose to consider the Wasserstein divergence instead of the original Jensen-Shannon (JS). In particular, under the optimal discriminator, minimizing the proposed value function with respect to the generator minimizes the Wasserstein distance between $P$ and $Q$ . The drawback is that one has to ensure a 1-Lipschitz discriminator due to exploited Kantorovich-Rubenstein duality. The corresponding loss functions are $\\mathcal { L } _ { \\mathrm { D } } ~ =$ $- \\mathbb { E } _ { x \\sim P } [ D ( x ) ] + \\mathbb { E } _ { \\hat { x } \\sim Q } [ D ( \\hat { x } ) ]$ and $\\mathcal { L } _ { \\mathrm { G } } = - \\mathbb { E } _ { \\hat { x } \\sim Q } [ D ( \\hat { x } ) ]$ . ",
+        "bbox": [
+            174,
+            321,
+            825,
+            406
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we consider the least-squares loss (LS) which corresponds to minimizing the Pearson $\\chi ^ { 2 }$ divergence between $P$ and $Q$ (Mao et al., 2016). The intuition is that this loss function is smooth and saturates slower than the sigmoid cross-entropy loss of the JS formulation. The corresponding loss functions are $\\mathcal { L } _ { \\mathrm { D } } = - \\mathbb { E } _ { x \\sim P } \\overline { { [ ( D ( x ) - 1 ) ^ { 2 } ] } } + \\tilde { \\mathbb { E } } _ { \\hat { x } \\sim Q } [ D ( \\hat { x } ) ^ { 2 } ]$ and $\\mathcal { L } _ { \\mathrm { G } } = - \\mathbb { E } _ { \\hat { x } \\sim Q } [ ( D ( \\hat { x } ) { \\bar { - } } 1 ) ^ { 2 } ]$ ]. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 REGULARIZATION AND NORMALIZATION OF THE DISCRIMINATOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            671,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Gradient norm penalty. In the context of Wasserstein GANs this penalty can be interpreted as a soft penalty for the violation of 1-Lipschitzness (WGAN GP) (Gulrajani et al., 2017). Hereby, the gradient is evaluated on a linear interpolation between training points and generated samples as a proxy to the optimal coupling. The gradient penalty can also be evaluated around the data manifold which encourages the discriminator to be piece-wise linear in that region (Dragan) (Kodali et al., 2017). However, the gradient norm penalty can be considered purely as a regularizer for the discriminator and it was shown that it can improve the performance for other losses (Fedus et al., 2018). Furthermore, the penalty can be scaled by the “confidence” of the discriminator in the context of f-divergences (Roth et al., 2017). A drawback of gradient penalty (GP) regularization scheme is that it can depend on the model distribution $Q$ which changes during training. One drawback of Dragan is that it is unclear to which extent the Gaussian assumption for the manifold holds. Finally, computing the gradient norms implies a non-trivial running time penalty – essentially doubling the running time. We also investigate the impact of a regularizer ubiquitous in supervised learning – the $L _ { 2 }$ penalty on all the weights of the network. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Discriminator normalization. Normalizing the discriminator can be useful from both the optimization perspective (more efficient gradient flow, a more stable optimization), as well as from the representation perspective – the representation richness of the layers in a neural network depends on the spectral structure of the corresponding weight matrices (Miyato et al., 2018). ",
+        "bbox": [
+            174,
+            719,
+            825,
+            775
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From the optimization point of view, several techniques have found their way into the GAN literature, namely batch normalization (BN) (Ioffe and Szegedy, 2015) and layer normalization (LN) (Ba et al., 2016). Batch normalization in the context of GANs was suggested by Denton et al. (2015) and further popularized by Radford et al. (2016). It normalizes the pre-activations of nodes in a layer to mean $\\beta$ and standard deviation $\\gamma$ , where both $\\beta$ and $\\gamma$ are parameters learned for each node in the layer. The normalization is done on the batch level and for each node separately. In contrast, with Layer normalization, all the hidden units in a layer share the same normalization terms $\\beta$ and $\\gamma$ , but different samples are normalized differently (Ba et al., 2016). Layer normalization was first applied in the context of GANs in Gulrajani et al. (2017). ",
+        "bbox": [
+            174,
+            781,
+            826,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From the representation point of view, one has to consider the neural network as a composition of (possibly non-linear) mappings and analyze their spectral properties. In particular, for the discriminator to be a bounded linear operator it suffices to control the maximum singular value. This approach is followed in Miyato et al. (2018) where the authors suggest dividing each weight matrix, including the matrices representing convolutional kernels, by their spectral norm. Furthermore, the authors argue that a key advantage of spectral normalization over competing approaches is that it results in discriminators of higher rank. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 GENERATOR AND DISCRIMINATOR ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            565,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We explore two classes of architectures in this study: deep convolutional generative adversarial networks (DCGAN) (Radford et al., 2016) and residual networks (ResNet) (He et al., 2016), both of which are ubiquitous in GAN research. Recently, Miyato et al. (2018) defined a variation of DCGAN, so called SNDCGAN. Apart from minor updates (cf. Section 4) the main difference to DCGAN is the use of an eight-layer discriminator network. The details of both networks are summarized in Table 3. The other architecture, ResNet19, is an architecture with five ResNet blocks in the generator and six ResNet blocks in the discriminator, that can operate on $1 2 8 \\times 1 2 8$ images. We follow the ResNet setup from Miyato et al. (2018), with the small difference that we simplified the design of the discriminator. The detailed parameters of discriminator and generator are summarized in Table 4a and Table 4b. With this setup we were able to reproduce the current state of the art results. An ablation study on various ResNet modifications is available in the Appendix. ",
+        "bbox": [
+            174,
+            280,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            375,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We focus on several recently proposed metrics well suited to the image domain. For an in-depth overview of quantitative metrics we refer the reader to (Borji, 2018). ",
+        "bbox": [
+            173,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inception Score (IS). Proposed by Salimans et al. (2016), IS offers a way to quantitatively evaluate the quality of generated samples. Intuitively, the conditional label distribution of samples containing meaningful objects should have low entropy, and the variability of the samples should be high. which can be expressed as $\\scriptstyle \\mathtt { I S } = \\exp ( \\mathbb { E } _ { x \\sim Q } [ d _ { K L } ^ { \\sim } ( p ( y \\mid x ) , p ( y ) ) ] )$ . The authors found that this score is well-correlated with scores from human annotators. Drawbacks include insensitivity to the prior distribution over labels and not being a proper distance. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As an alternative Heusel et al. (2017) proposed the Frechet Inception Distance (FID). Samples from $P$ and $Q$ are first embedded into a feature space (a specific layer of InceptionNet). Then, assuming that the embedded data follows a multivariate Gaussian distribution, the mean and covariance are estimated. Finally, the Frechet distance between these two Gaussians is computed, i.e. ´ ",
+        "bbox": [
+            174,
+            603,
+            825,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6f8ed1562991b68fbd061fe2c043b6c232d23ac1a6f53fbb10018323336362d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathtt { F I D } = | | \\mu _ { x } - \\mu _ { y } | | _ { 2 } ^ { 2 } + \\operatorname { T r } \\big ( \\Sigma _ { x } + \\Sigma _ { y } - 2 \\big ( \\Sigma _ { x } \\Sigma _ { y } \\big ) ^ { \\frac { 1 } { 2 } } \\big ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            666,
+            668,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\left( \\mu _ { x } , \\Sigma _ { x } \\right)$ , and $( \\mu _ { y } , \\Sigma _ { y } )$ are the mean and covariance of the embedded samples from $P$ and $Q$ , respectively. The authors argue that FID is consistent with human judgment and more robust to noise than IS. Furthermore, the score is sensitive to the visual quality of generated samples – introducing noise or artifacts in the generated samples will reduce the FID. In contrast to IS, FID can detect intra-class mode dropping, i.e. a model that generates only one image per class can score a perfect IS, but will suffer from have a high FID (Lucic et al., 2018). Binkowski et al. ´ (2018) argued that FID has no unbiased estimator and suggest Kernel Inception distance (KID) instead. In Appendix B we empirically compare KID to FID and observe that both metrics are very strongly correlated (Spearman rank-order correlation coefficient of 0.994 for LSUN-BEDROOM and 0.995 for CELEBA-HQ-128 datasets). As a result we focus on FID as it is likely to result in the same ranking. ",
+        "bbox": [
+            173,
+            693,
+            826,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-scale Structural Similarity for Image Quality (MS-SSIM) and Diversity. A critical issue in GANs are mode collapse and mode-dropping – failing to capture a mode, or low-diversity of generated samples from a given mode. The MS-SSIM score (Wang et al., 2003) is used for measuring the similarity of two images where higher MS-SSIM score indicates more similar images. Several recent works suggest using the average pairwise MS-SSIM score within a given class as a proxy for the diversity of generated samples (Odena et al., 2017; Fedus et al., 2018). The drawback of this approach is that we do not know the class corresponding to the generated sample, so it is usually applied on one-class data sets, such as CELEBA-HQ-128. In this work we use the same setup as in Fedus et al. (2018). In particular, given a batch size $b$ , we compute the average pairwise MS-SSIM score on 5 batches, of $5 \\times b \\times ( b - 1 ) / 2$ image pairs in total. We stress that the diversity should only be taken into account together with the FID and $I S$ metrics. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/5b538da34a3ed222dafa89ec8eb797b9aceb13eabaf767453d4ccb5b8d38cf29.jpg",
+        "table_caption": [
+            "Table 1: Hyperparameter ranges used in this study. The Cartesian product of the fixed values suffices to uncover the existing results. Gaussian Process optimization in the bandit setting (Srinivas et al., 2010) is used to select good hyperparameter settings from the specified ranges. ",
+            "(a) Fixed values "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>PARAMETER</td><td>DISCRETE VALUE</td></tr><tr><td>Learning rate α</td><td>{0.0002,0.0001,0.001}</td></tr><tr><td>Reg. strength 入</td><td>{1,10}</td></tr><tr><td>(β1,β2,ndis)</td><td>{(0.5,0.900,5), (0.5,0.999,1), (0.5,0.999,5), (0.9,0.999,5)}</td></tr></table>",
+        "bbox": [
+            173,
+            174,
+            501,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d1f194fba1fef258921265d4927c729e33c5909fbd7dc85dc8411aace932d66.jpg",
+        "table_caption": [
+            "(b) Gaussian Process regression ranges "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>PARAMETER</td><td>RANGE</td><td>LOG</td></tr><tr><td>Learning rate α</td><td>[10-5,10-2]</td><td>Yes</td></tr><tr><td>入 for L2</td><td>[10-4,101]</td><td>Yes</td></tr><tr><td>入 for non-L2</td><td>[10-1,102]</td><td>Yes</td></tr><tr><td>β1×β</td><td>[0,1] × [0,1]</td><td>No</td></tr></table>",
+        "bbox": [
+            544,
+            174,
+            805,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            294,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 DATA SETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            382,
+            292,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider three data sets, namely CIFAR10, CELEBA-HQ-128, and LSUN-BEDROOM. The LSUN-BEDROOM data set (Yu et al., 2015) contains slightly more than 3 million images3. We randomly partition the images into a train and test set whereby we use 30588 images as the test set. Secondly, we use the CELEBA-HQ data set of 30k images (Karras et al., 2018). We use the $1 2 8 \\times 1 2 8 \\times 3$ version obtained by running the code provided by the authors.4 We use 3000 examples as the test set and the remaining examples as the training set. Finally, we also include the CIFAR10 data set which contains 70K images $\\left( 3 2 \\mathbf { x } 3 2 \\mathbf { x } 3 \\right)$ , partitioned into 60000 training instances and 10000 testing instances. The baseline FID scores are 12.6 for CELEBA-HQ-128, 3.8 for LSUN-BEDROOM, and 5.19 for CIFAR10. Details on FID computation are presented in Section 4. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.6 EXPLORING THE GAN LANDSCAPE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            462,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The search space for GANs is prohibitively expensive: exploring all combinations of all losses, normalization and regularization schemes, and architectures is outside of the practical realm. Instead, in this study we analyze several slices of this tensor for each data set. In particular, to ensure that we can reproduce existing results, we perform a study over the subset of this tensor on CIFAR10. We then proceed to analyze the performance of these models across CELEBA-HQ-128 and LSUN-BEDROOM. In Section 3.1 we fix everything but the loss. In Section 3.2 we fix everything but the regularization and normalization scheme. Finally, in Section 3.3 we fix everything but the architecture. This allows us to decouple some of these design choices and provide some insight on what matters most. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As noted in Lucic et al. (2018), one major issue preventing further progress is the hyperparameter tuning – currently, the community has converged to a small set of parameter values which work on some data sets, and may completely fail on others. In this study we combine the best hyperparameter settings found in the literature (Miyato et al., 2018), and perform Gaussian Process regression in the bandit setting (Srinivas et al., 2010) to possibly uncover better hyperparameter settings. We then consider the top performing models and discuss the impact of the computational budget. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We summarize the fixed hyperparameter settings in Table 1a which contains the “good” parameters reported in recent publications (Fedus et al., 2018; Miyato et al., 2018; Gulrajani et al., 2017). In particular, we consider the cross product of these parameters to obtain 24 hyperparameter settings to reduce the bias. Finally, to provide a fair comparison, we perform Gaussian Process optimization in the bandit setting (Srinivas et al., 2010) on the parameter ranges provided in Table 1b. We run 12 rounds (i.e. we communicate with the oracle 12 times) of the optimization, each with a batch of 10 hyperparameter sets selected based on the FID scores from the results of the previous iterations. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7632ddba45f2ade2676217c086988ad49718568456061ecaba4e597982b4dfe.jpg",
+        "image_caption": [
+            "Figure 1: Impact of the loss function: FID distribution for top $5 \\%$ models. The non-saturating (NS) loss is stable over both data sets. Gradient penalty and spectral normalization improve the sample quality. From the computational budget perspective (i.e. how many models one needs to train to reach a certain FID), both spectral normalization and gradient penalty perform better than the baseline, but the former is more efficient. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            821,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As we explore the number of discriminator updates per generator update (1 or 5), this leads to an additional 240 hyperparameter settings which in some cases outperform the previously known hyperparameter settings. Batch size is set to 64 for all the experiments. We use a fixed the number of discriminator update steps of 100K for LSUN-BEDROOM data set and CELEBA-HQ-128 data set, and 200K for CIFAR10 data set. We apply the Adam optimizer (Kingma and Ba, 2015). ",
+        "bbox": [
+            174,
+            454,
+            825,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            550,
+            431,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given that there are 4 major components (loss, architecture, regularization, normalization) to analyze for each data set, it is infeasible to explore the whole landscape. Hence, we opt for a more pragmatic solution – we keep some dimensions fixed, and vary the others. For each experiment we highlight three aspects: (1) FID distribution of the top $5 \\%$ of the trained models, (2) the corresponding sample diversity score, and (3) the tradeoff between the computational budget (i.e. number of models to train) and model quality in terms of FID. Each model was retrained 5 times with a different random seed and we report the median score. The variance for models obtained by Gaussian Process regression is handled implicitly so we train each model once. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 IMPACT OF THE LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            720,
+            441,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here the loss is either the non-saturating loss (NS) (Goodfellow et al., 2014), the least-squares loss (LS) (Mao et al., 2016), or the Wasserstein loss (WGAN) (Arjovsky et al., 2017). We use the ResNet19 with generator and discriminator architectures detailed in Table 4a. We consider the most prominent normalization and regularization approaches: gradient penalty (Gulrajani et al., 2017), and spectral normalization (Miyato et al., 2018). Both studies were performed on CELEBA-HQ-128 and LSUN-BEDROOM with hyperparameter settings shown in Table 1a. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Figure 1. We observe that the non-saturating loss is stable over both data sets. Spectral normalization improves the quality of the model on both data sets. Similarly, the gradient penalty can help improve the quality of the model, but finding a good regularization tradeoff is non-trivial and requires a high computational budget. Models using the GP penalty benefit from 5:1 ratio of discriminator to generator updates as suggested by (Gulrajani et al., 2017). We also performed a study on hinge loss (Miyato et al., 2018) and present it in the Appendix. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/82e848101388335cba5420ecc90eab32f9659adccd2f642efa36a986d2c1d407.jpg",
+        "image_caption": [
+            "Figure 2: Impact of regularization and normalization: FID distribution for top $5 \\%$ models. Both gradient penalty (GP) and spectral normalization (SN) outperform the baseline and should be considered, while former being more computationally expensive. Unfortunately none fully address the stability issues. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            821,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 IMPACT OF REGULARIZATION AND NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            580,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The goal of this study is to compare the relative performance of various regularization and normalization methods presented in the literature. To this end, and based on the loss study, we fix the loss to non-saturating loss (Goodfellow et al., 2014). We use the ResNet19 with generator and discriminator architectures described in Table 4a. Finally, we consider batch normalization (BN) (Ioffe and Szegedy, 2015), layer normalization (LN) (Ba et al., 2016), spectral normalization (SN), gradient penalty (GP) (Gulrajani et al., 2017), dragan penalty (DR) (Kodali et al., 2017), or $L _ { 2 }$ regularization. We consider both CELEBA-HQ-128 and LSUN-BEDROOM with the hyperparameter settings shown in Table 1a and Table 1b. ",
+        "bbox": [
+            173,
+            460,
+            826,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Figure 2. We observe that adding batch norm to the discriminator hurts the performance. Secondly, gradient penalty can help, but it doesn’t stabilize the training. In fact, it is non-trivial to strike a balance of the loss and regularization strength. Spectral normalization helps improve the model quality and is more computationally efficient than gradient penalty. This is consistent with recent results in Zhang et al. (2018). Similarly to the loss study, models using GP penalty benefit from 5:1 ratio of discriminator to generator updates. Furthermore, in a separate ablation study we observed that running the optimization procedure for an additional 100K steps is likely to increase the performance of the models with GP penalty. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Impact of Simultaneous Regularization and Normalization. Given the folklore that the Lipschitz constant of the discriminator is critical for the performance, one may expect simultaneous regularization and normalization could improve model quality. To quantify this effect, we fix the loss to non-saturating loss (Goodfellow et al., 2014), use the Resnet19 architecture (as above), and combine several normalization and regularization schemes, with hyperparameter settings shown in Table 1a coupled with 24 randomly selected parameters. The results are presented in Figure 3. We observe that one may benefit from additional regularization and normalization. However, a lot of computational effort has to be invested for somewhat marginal gains in FID. Nevertheless, given enough computational budget we advocate simultaneous regularization and normalization – spectral normalization and layer normalization seem to perform well in practice. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/46e4df44d5fbb143416866b4220f7afea497ffb5bb5691af926e9d009ed5d8ec.jpg",
+        "image_caption": [
+            "Figure 3: Impact of simultaneous normalization and regularization: FID distribution for top $5 \\%$ models. Gradient penalty coupled with spectral normalization (SN) or layer normalization (LN) strongly improves the performance over the baseline. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            752,
+            823,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 IMPACT OF GENERATOR AND DISCRIMINATOR ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            233,
+            658,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An interesting practical question is whether our findings also hold for a different model capacity. To this end, we also perform a study on SNDCGAN from Miyato et al. (2018). We consider the non-saturating GAN loss, gradient penalty and spectral normalization. While for smaller architectures regularization is not essential (Lucic et al., 2018), the regularization and normalization effects might become more relevant due to deeper architectures and optimization considerations. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e965e3c9706e0a9c32f50c8a17e42a830c7fba8c8e37ec83f2e9451c076d310.jpg",
+        "image_caption": [
+            "Figure 4: Impact of the neural architectures: FID distribution for top $5 \\%$ models. Both spectral normalization and gradient penalty can help improve upon the non-regularized baseline. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            344,
+            821,
+            582
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Figure 4. We observe that both architectures achieve comparable results and benefit from regularization and normalization. Spectral normalization strongly outperforms the baseline for both architectures. ",
+        "bbox": [
+            174,
+            640,
+            821,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 COMMON PITFALLS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            370,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we focus on several pitfalls we encountered while trying to reproduce existing results and provide a fairly and accurate comparison. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Metrics. There already seems to be a divergence in how the FID score is computed: (1) Some authors report the score on training data, yielding a FID between 50k training and $5 0 \\mathrm { k }$ generated samples (Unterthiner et al., 2018). Some opt to report the FID based on 10k test samples and $5 \\mathrm { k }$ generated samples and use a custom implementation (Miyato et al., 2018). Finally, Lucic et al. (2018) report the score with respect to the test data, in particular FID between 10k test samples, and 10k generated samples. The subtle differences will result in a mismatch between the reported FIDs, in some cases of more than $1 0 \\%$ . We argue that FID should be computed with respect to the test data set as and use 10k test samples and 10k generated samples on CIFAR10 and LSUN-BEDROOM, and 3k vs 3k on CELEBA-HQ-128 as in in Lucic et al. (2018). Similarly, there are several ways to compute a diversity score using MS-SSIM and we follow the approach from Fedus et al. (2018). We provide the implementation details in Section G of the Appendix. ",
+        "bbox": [
+            173,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Details of neural architectures. Even in popular architectures, like ResNet, there is still a number of design decision one needs to make, that are often omitted from the reported results. Those include the exact design of the ResNet cell (order of layers, when is ReLu applied, when to upsample and downsample, how many filters to use). Some of these differences might lead to potentially unfair comparison. As a result, we suggest to use the architectures presented within this work as a solid baseline. An ablation study on various ResNet modifications is available in the Appendix. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Data sets. A common issue is related to data set processing – does LSUN-BEDROOM always correspond to the same data set? In most cases the precise algorithm for upscaling or cropping is not clear which introduces inconsistencies between results on the “same” data set. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementation details and non-determinism. One major issue is the mismatch between the algorithm presented in a paper and the code provided online. We are aware that there is an embarrassingly large gap between a good implementation and a bad implementation of a given model. Hence, when no code is available, one is forced to guess which modifications were done. Another particularly tricky issue is removing randomness from the training process. After one fixes the data ordering and the initial weights, obtaining the same score by training the same model twice is non-trivial due to randomness present in certain GPU operations (Chetlur et al., 2014). Disabling the optimizations causing the non-determinism often results in an order of magnitude running time penalty. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While each of these issues taken in isolation seems minor, they compound to create a mist which introduces friction in practical applications and the research process (Sculley et al., 2018). ",
+        "bbox": [
+            174,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            344,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A recent large-scale study on GANs and Variational Autoencoders was presented in Lucic et al. (2018). The authors consider several loss functions and regularizers, and study the effect of the loss function on the FID score, with low-to-medium complexity data sets (MNIST, CIFAR10, CELEBA), and a single (InfoGAN style) architecture. In this limited setting, the authors found that there is no statistically significant difference between recently introduced models and the original non-saturating GAN. A study of the effects of gradient-norm regularization in GANs was recently presented in Fedus et al. (2018). The authors posit that the gradient penalty can also be applied to the non-saturating GAN, and that, to a limited extent, it reduces the sensitivity to hyperparameter selection. In a recent work on spectral normalization, the authors perform a small study of the competing regularization and normalization approaches (Miyato et al., 2018). We are happy to report that we could reproduce these results and we present them in the Appendix. ",
+        "bbox": [
+            174,
+            441,
+            825,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Inspired by these works and building on the available open-source code from Lucic et al. (2018), we take one additional step in all dimensions considered therein: more complex neural architectures, more complex data sets, and more involved regularization and normalization schemes. ",
+        "bbox": [
+            176,
+            602,
+            823,
+            643
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            664,
+            318,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we study the GAN landscape: losses, regularization and normalization schemes, and neural architectures, and their impact on the on the quality of generated samples which we assess by recently introduced quantitative metrics. Our fair and thorough empirical evaluation suggests that one should consider non-saturating GAN loss and spectral normalization as default choices when applying GANs to a new data set. Given additional computational budget, we suggest adding the gradient penalty from Gulrajani et al. (2017) and train the model until convergence. Furthermore, additional marginal gains can be obtained by combining normalization and regularization empirically confirming the importance of the Lipschitz constant of the discriminator. Furthermore, both types of architectures proposed up-to this point perform reasonably well. A separate ablation study uncovered that most of the tricks applied in the ResNet style architectures lead to marginal changes in the quality and should be avoided due to the high computational cost. As a result of this large-scale study we identify the common pitfalls standing in the way of accurate and fair comparison and propose concrete actions to demystify the future results – issues with metrics, data set preprocessing, non-determinism, and missing implementation details are particularly striking. We hope that this work, together with the open-sourced reference implementations and trained models, will serve as a solid baseline for future GAN research. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eirikur Agustsson, Michael Tschannen, Fabian Mentzer, Radu Timofte, and Luc Van Gool. Generative adversarial networks for extreme learned image compression. CoRR, abs/1804.02958, 2018. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. In ´ International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            174,
+            160,
+            821,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            171,
+            195,
+            823,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikołaj Binkowski, Dougal J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD GANs. In ´ International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ali Borji. Pros and cons of GAN evaluation measures. arXiv preprint arXiv:1802.03446, 2018. ",
+        "bbox": [
+            176,
+            266,
+            740,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cudnn: Efficient primitives for deep learning. arXiv preprint arXiv:1410.0759, 2014. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in Neural Information Processing Systems (NIPS), 2015. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "William Fedus, Mihaela Rosca, Balaji Lakshminarayanan, Andrew M Dai, Shakir Mohamed, and Ian Goodfellow. Many paths to equilibrium: Gans do not need to decrease a divergence at every step. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            176,
+            361,
+            823,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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 (NIPS), 2014. ",
+        "bbox": [
+            176,
+            409,
+            823,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of Wasserstein GANs. Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            171,
+            457,
+            823,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            171,
+            492,
+            823,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and Sepp Hochre-¨ iter. GANs trained by a two time-scale update rule converge to a Nash equilibrium. Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            174,
+            612,
+            823,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            683,
+            821,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Naveen Kodali, Jacob Abernethy, James Hays, and Zsolt Kira. On convergence and stability of GANs. arXiv preprint arXiv:1705.07215, 2017. ",
+        "bbox": [
+            171,
+            718,
+            823,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are GANs created equal? A large-scale study. Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            171,
+            753,
+            823,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. arXiv preprint ArXiv:1611.04076, 2016. ",
+        "bbox": [
+            173,
+            790,
+            821,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            176,
+            825,
+            821,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            174,
+            861,
+            823,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            173,
+            104,
+            825,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin Roth, Aurelien Lucchi, Sebastian Nowozin, and Thomas Hofmann. Stabilizing training of generative adversarial networks through regularization. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            166
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            176,
+            174,
+            823,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. Sculley, Jasper Snoek, Alex Wiltschko, and Ali Rahimi. Winner’s curse? On pace, progress, and empirical rigor, 2018. ",
+        "bbox": [
+            174,
+            209,
+            821,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Niranjan Srinivas, Andreas Krause, Sham Kakade, and Matthias W. Seeger. Gaussian process optimization in the bandit setting: No regret and experimental design. In International Conference on Machine Learning (ICML), 2010. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Tschannen, Eirikur Agustsson, and Mario Lucic. Deep generative models for distribution-preserving lossy compression. Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            169,
+            292,
+            823,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Unterthiner, Bernhard Nessler, Calvin Seward, Gnter Klambauer, Martin Heusel, Hubert Ramsauer, and Sepp Hochreiter. Coulomb GANs: Provably optimal nash equilibria via potential fields. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            176,
+            328,
+            821,
+            367
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems and Computers, 2003. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365, 2015. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018. ",
+        "bbox": [
+            174,
+            446,
+            821,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A FID AND INCEPTION SCORES ON CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            571,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We present an empirical study with SNDCGAN and ResNet CIFAR architectures on CIFAR10 in figure 5 and figure 6. In addition to Section 3.1, we evaluate one more kind of loss on CIFAR10. Here HG, NS and WGAN stand for hinge loss, non saturating loss and Wasserstein loss respectively. We observe that hinge loss performs very similar to non-saturating loss. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/c164b1f15578e4a9ef02160d0cfbbfa32f06c4db8cef2e901de85c271df39446.jpg",
+        "image_caption": [
+            "Figure 5: An empirical study with SNDCGAN and ResNet cifar architectures on CIFAR10. We recover the state of the art results recently reported in Miyato et al. (2018). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            195,
+            738,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/9336b9938cfebbfb0ad26108c3d376665c6fce35dadf469e8a26634157b3acfa.jpg",
+        "image_caption": [
+            "Figure 6: We show the Inception Score for each model within our study which corresponds to recently reported results (Miyato et al., 2018). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            395,
+            754,
+            537
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B COMPARISON OF FID AND KID METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            595,
+            552,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The KID metric introduced by Binkowski et al. ´ (2018) is an alternative to FID. We use models from our Regularization and Normalization study (see Section 3.2) to compare both metrics. Here, by model we denote everything that needs to be specified for the training – including all hyper-parameters, like learning rate, $\\lambda$ , Adam’s $\\beta$ , etc. The Spearman rank-order correlation coefficient between KID and FID scores is approximately 0.994 for LSUN-BEDROOM and 0.995 for CELEBA-HQ-128 datasets. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To evaluate a practical setting of selecting several best models, we compare the intersection between the set of “best $K$ models by FID” and the set of “best $K$ models by KID” for $\\bar { K } \\in { 5 , 1 0 , 2 0 , 5 0 , 1 0 0 }$ . The results are summarized in Table 2. ",
+        "bbox": [
+            174,
+            696,
+            823,
+            734
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This experiment suggests that FID and KID metrics are very strongly correlated, and for the practical applications one can choose either of them. Also, the conclusions from our studies based on FID should transfer to studies based on KID. ",
+        "bbox": [
+            176,
+            742,
+            823,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/c60d6fe1829ddd8eeca7bb19462437aaad4c277acacf61b026209b0ac306cbc3.jpg",
+        "table_caption": [
+            "Table 2: Intersection between set of top $K$ experiments selected by FID and KID metrics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LSUN-BEDROOM CELEBA-HQ-128</td></tr><tr><td>K=5 4/5</td><td>2/5</td></tr><tr><td>K=10</td><td>9/10 8/10</td></tr><tr><td>K=20</td><td>18/20 15/20</td></tr><tr><td>K=50 49/50</td><td>46/50</td></tr><tr><td>K=100</td><td>95/100 98/100</td></tr></table>",
+        "bbox": [
+            321,
+            816,
+            671,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            352,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C.1 SNDCGAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            302,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We used the same architecture as Miyato et al. (2018), with the parameters copied from the GitHub page5. In Table 3a and Table 3b, we describe the operations in layer column with order. Kernel size is described in format [f ilter h, f ilter $_ - w$ , stride], input shape is $h \\times w$ and output shape is $h \\times w \\times c h a n n e l s$ . The slopes of all lReLU functions are set to 0.1. The input shape $h \\times w$ is $1 2 8 \\times 1 2 8$ for CELEBA-HQ-128 and LSUN-BEDROOM, $3 2 \\times 3 2$ for CIFAR10. ",
+        "bbox": [
+            174,
+            157,
+            826,
+            220
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e923ebf37b598ddef5916cb4c889c811faeff69618557723902403d2c8589aa.jpg",
+        "table_caption": [
+            "Table 3: SNDCGAN architecture. ",
+            ""
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">(a) SNDCGANdiscriminator</td></tr><tr><td>LAYER KERNEL</td><td>OUTPUT</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h×w×64</td></tr><tr><td>Conv, IReLU [4,4,2]</td><td>h/2 × w/2 × 128</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/2 × w/2 × 128</td></tr><tr><td>Conv, lReLU [4,4,2]</td><td>h/4 × w/4× 256</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/4 × w/4 × 256</td></tr><tr><td>Conv, IReLU [4,4,2]</td><td>h/8×w/8× 512</td></tr><tr><td>Conv, IReLU [3,3,1]</td><td>h/8×w/8× 512</td></tr><tr><td>Linear 1</td><td>1</td></tr></table>",
+        "bbox": [
+            183,
+            263,
+            485,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/c887e9053f30412212aeaa774cfa1b8c75f53b6c8dc2156daf4baae6b43269d7.jpg",
+        "table_caption": [
+            "(b) SNDCGAN generator"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL OUTPUT</td></tr><tr><td>2 1</td><td>128</td></tr><tr><td>Linear, BN, ReLU</td><td>h/8×w/8× 512 1</td></tr><tr><td>Deconv, BN, ReLU [4,4,2]</td><td>h/4 ×w/4 × 256</td></tr><tr><td>Deconv,BN,ReLU</td><td>[4,4,2] h/2 × w/2 × 128</td></tr><tr><td>Deconv, BN, ReLU</td><td>[4,4,2] h×w×64</td></tr><tr><td>Deconv, Tanh [3,3,1]</td><td>h×w×3</td></tr></table>",
+        "bbox": [
+            496,
+            280,
+            836,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C.2 RESNET ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            392,
+            492
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The ResNet19 architecture is described in Table 4. RS column stands for the resample of the residual block, with downscale(D)/upscale(U)/none(-) setting. MP stands for mean pooling and BN for batch normalization. ResBlock is defined in Table 5. The addition layer merges two paths by adding them. The first path is a shortcut layer with exactly one convolution operation, while the second path consists of two convolution operations. The downscale layer and upscale layer are marked in Table 5. We used average pool with kernel [2, 2, 2] for downscale, after the convolution operation. We used unpool from https://github.com/tensorflow/ tensorflow/issues/2169 for upscale, before convolution operation. $h$ and $w$ are the input shape to the ResNet block, output shape depends on the RS parameter. $c _ { i }$ and $c _ { o }$ are the input channels and output channels for a ResNet block. Table 6 described the ResNet CIFAR architecture we used in Figure 5 for reproducing the existing results. Note that RS is set to none for third ResBlock and fourth ResBlock in discriminator. In this case, we used the same ResNet block defined in Table 5 without resampling. ",
+        "bbox": [
+            173,
+            502,
+            826,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/3371b9fe1e5470bcbc964c2da5cddcec698e66dfcfc294f2401c22fc485b41b2.jpg",
+        "table_caption": [
+            "Table 4: ResNet 19 architecture corresponding to “resnet small” in https://github.com/ pfnet-research/sngan_projection. ",
+            "(a) ResNet19 discriminator "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS OUTPUT</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>64 × 64× 64</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>32 × 32 ×128</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>16 ×16× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>8×8× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>4 ×4 × 512</td></tr><tr><td>ResBlock</td><td>[3,3,1] D</td><td>2 ×2× 512</td></tr><tr><td>ReLU, MP</td><td>-</td><td>512</td></tr><tr><td>Linear</td><td>- -</td><td>1</td></tr></table>",
+        "bbox": [
+            181,
+            161,
+            488,
+            333
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e22b1f5de7b1414ef9666679623aab2158525f437a8c06fd1ad3edb9eed4c348.jpg",
+        "table_caption": [
+            "(b) ResNet19 generator ",
+            "Table 5: ResNet block definition. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>2</td><td></td><td>1</td><td>128</td></tr><tr><td>Linear</td><td>-</td><td>1</td><td>4×4× 512</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>8×8×512</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>16 × 16× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>32 × 32 × 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>64 × 64 × 128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>128 × 128 × 64</td></tr><tr><td>BN,ReLU</td><td>1</td><td>1</td><td>128 × 128 × 64</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>1</td><td>128 × 128× 3</td></tr><tr><td>Sigmoid</td><td>-</td><td>-</td><td>128 × 128 × 3</td></tr></table>",
+        "bbox": [
+            501,
+            161,
+            815,
+            371
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a61bc2dad7dee5dcad94d154d90410fe845958823dc1c5900db22bd41de52002.jpg",
+        "table_caption": [
+            "(a) ResBlock discriminator ",
+            "Table 6: ResNet CIFAR architecture. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>Shortcut</td><td>[3,3,1]</td><td>D</td><td>h/2 × w/2 × Co</td></tr><tr><td>BN,ReLU</td><td>1</td><td>1</td><td>hxwXCi</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>-</td><td>h×w×co</td></tr><tr><td>BN,ReLU</td><td>=</td><td>=</td><td>h×w×co</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>D</td><td>h/2 × w/2 ×Co</td></tr><tr><td>Addition</td><td>-</td><td>-</td><td>h/2 × w/2 × Co</td></tr></table>",
+        "bbox": [
+            176,
+            439,
+            495,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/053517377514aa384c0fbeda5aa3aed15d8d4f2c604fb022c2d63e85f5134cee.jpg",
+        "table_caption": [
+            "(b) ResBlock generator "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>Shortcut</td><td>[3,3,1]</td><td>U</td><td>2h× 2w XCo</td></tr><tr><td>BN, ReLU</td><td>1</td><td>-</td><td>h×wXCi</td></tr><tr><td rowspan=\"3\">Conv BN, ReLU</td><td>[3,3,1]</td><td>U</td><td>2h ×2w×Co</td></tr><tr><td>-</td><td>1</td><td>2h × 2w ×Co</td></tr><tr><td>[3,3,1]</td><td>1</td><td>2h ×2w×Co</td></tr><tr><td>Conv Addition</td><td>-</td><td>-</td><td>2h × 2w X Co</td></tr></table>",
+        "bbox": [
+            508,
+            439,
+            810,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2567f6e717cbbb3a6469ac38bb4b519636686f6c2a4a0b5ef55034ed2dd1abd.jpg",
+        "table_caption": [
+            "(a) ResNet CIFAR discriminator "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS OUTPUT</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>D 16 × 16 × 128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>D 8×8×128</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>8×8×128 -</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>- 8×8×128</td></tr><tr><td>ReLU, MP</td><td></td><td>128 -</td></tr><tr><td>Linear</td><td>-</td><td>- 1</td></tr></table>",
+        "bbox": [
+            181,
+            622,
+            488,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/493a6bfc4c66827df5e99eb1a8fde9a99c1078cb4ceb973deca077470d7e2ced.jpg",
+        "table_caption": [
+            "(b) ResNet CIFAR generator "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>KERNEL</td><td>RS</td><td>OUTPUT</td></tr><tr><td>2</td><td></td><td>-</td><td>128</td></tr><tr><td>Linear</td><td>-</td><td>-</td><td>4×4×256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>8×8× 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>16 × 16 × 256</td></tr><tr><td>ResBlock</td><td>[3,3,1]</td><td>U</td><td>32 × 32 × 256</td></tr><tr><td>BN, ReLU</td><td>1</td><td>1</td><td>32 × 32× 256</td></tr><tr><td>Conv</td><td>[3,3,1]</td><td>-</td><td>32 × 32 × 3</td></tr><tr><td>Sigmoid</td><td>1</td><td>-</td><td>32 × 32 × 3</td></tr></table>",
+        "bbox": [
+            504,
+            622,
+            812,
+            795
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D RESNET ARCHITECTURE ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            575,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We have noticed six minor differences on Resnet architecture comparing to implementation from https: //github.com/pfnet-research/chainer-gan-lib/blob/master/common/net.py (Miyato et al., 2018). We did ablation study to verify the impact of these differences. Figure 7 shows the impact of the ablation study, with details described as following. ",
+        "bbox": [
+            174,
+            132,
+            826,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• DEFAULT: ResNet CIFAR architecture with spectral normalization and non-saturating GAN loss.   \n• SKIP: Use input as output for the shortcut connection in the discriminator ResBlock. By default it was a conv layer with 3x3 kernel.   \nCIN: Use $c _ { i }$ for the discriminator ResBlock hidden layer output channels. By default it was $c _ { o }$ in our setup, while Miyato et al. (2018) used $c _ { o }$ for first ResBlock and $c _ { i }$ for the rest. OPT: Use an optimized setup for the first discriminator ResBlock, which includes: (1) no ReLU, (2) a conv layer for the shortcut connections, (3) use $c _ { o }$ instead of $c _ { i }$ in ResBlock.   \nCIN OPT: Use CIN and OPT together. It means the first ResBlock is optimized while the remaining ResBlocks use $c _ { i }$ for the hidden output channels.   \n• SUM: Use reduce sum for the discriminator output. By default it was reduce mean.   \n• TAN: Use tanh for the generator output, as well as range [-1, 1] for discriminator input. By default it was sigmoid and discriminator input range [0, 1].   \nEPS: Use a bigger epsilon $\\mathrm { 2 e - 5 }$ for generator batch normalization. By default it was 1e − 5 in TensorFlow.   \n• ALL: Apply all the above differences together. ",
+        "bbox": [
+            215,
+            196,
+            825,
+            434
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the ablation study, the CIN experiment obtained the worst FID score. Combining with OPT, the CIN results were improved to the same level as the others which is reasonable because the first block has three input channels, which becomes a bottleneck for the optimization. Hence, using OPT and CIN together performs as well as the others. Overall, the impact of these differences are minor according to the study on CIFAR10. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            497
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/915843060e097817e89e5ef818f9f0c36cdf124f39cb363d94c6249fa26e25de.jpg",
+        "image_caption": [
+            "Figure 7: Ablation study of ResNet architecture differences. The experiment codes are described in Section D. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            512,
+            759,
+            650
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E RECOMMENDED HYPERPARAMETER SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            593,
+            737
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To make the future GAN training simpler, we propose a set of best parameters for three setups: (1) Best parameters without any regularizer. (2) Best parameters with only one regularizer. (3) Best parameters with at most two regularizers. Table 7, Table 8 and Table 9 summarize the top 2 parameters for SNDCGAN architecture, ResNet19 architecture and ResNet CIFAR architecture, respectively. Models are ranked according to the median FID score of five different random seeds with fixed hyper-parameters in Table 1a. Note that ranking models according to the best FID score of different seeds will achieve better but unstable result. Gaussian Process optimization hyper-parameters are not included in this table. For ResNet19 architecture with at most two regularizers, we have run it only once due to computational overhead. To show the model stability, we listed the best FID score out of five seeds from the same parameters in column best. Spectral normalization is clearly outperforms the other normalizers on SNDCGAN and ResNet CIFAR architectures, while on ResNet19 both layer normalization and spectral normalization work well. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            890
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To visualize the FID score on each data set, Figure 8, Figure 9 and Figure 10 show the generated examples by GANs. We select the examples from the best FID run, and then increase the FID score for two more plots. ",
+        "bbox": [
+            173,
+            897,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/517095517d9657f93ac21ca52943d038f6f799595f9e6be1d0b18ed16b891c58.jpg",
+        "table_caption": [
+            "Table 7: SNDCGAN parameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β1</td><td>β</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CIFAR10</td><td>29.75</td><td>28.66</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>1</td></tr><tr><td>CIFAR10</td><td>36.12</td><td>33.23</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>=</td></tr><tr><td>CELEBA-HQ-128</td><td>66.42</td><td>63.13</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>CELEBA-HQ-128</td><td>67.39</td><td>64.59</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>=</td></tr><tr><td>LSUN-BEDROOM</td><td>180.36</td><td>160.12</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>LSUN-BEDROOM</td><td>188.99</td><td>162.00</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>1</td></tr><tr><td>CIFAR10</td><td>26.66</td><td>25.27</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>CIFAR10</td><td>27.32</td><td>26.97</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>31.14</td><td>29.05</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>33.52</td><td>31.92</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>63.46</td><td>58.13</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>74.66</td><td>59.94</td><td>1.000</td><td>0.500</td><td>0.999</td><td>1</td><td>-</td><td>SN</td></tr><tr><td>CIFAR10</td><td>26.23</td><td>26.01</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN+GP</td></tr><tr><td>CIFAR10</td><td>26.66</td><td>25.27</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>31.13</td><td>30.80</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>GP</td></tr><tr><td>CELEBA-HQ-128</td><td>31.14</td><td>29.05</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>63.46</td><td>58.13</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>66.58</td><td>65.75</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>GP</td></tr></table>",
+        "bbox": [
+            171,
+            127,
+            828,
+            417
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/09f6b23750df3b53d8db071533a0bb9279cb8b391a26190ff51b903c06c8e150.jpg",
+        "table_caption": [
+            "Table 8: ResNet19 parameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β</td><td>阳</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CELEBA-HQ-128</td><td>43.73</td><td>39.10</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td></td><td></td></tr><tr><td>CELEBA-HQ-128</td><td>43.77</td><td>39.60</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>-</td></tr><tr><td>LSUN-BEDROOM</td><td>160.97</td><td>119.58</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td></td><td></td></tr><tr><td>LSUN-BEDROOM</td><td>161.70</td><td>125.55</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>=</td><td>1</td></tr><tr><td>CELEBA-HQ-128</td><td>32.46</td><td>28.52</td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>=</td><td>LN</td></tr><tr><td>CELEBA-HQ-128</td><td>40.58</td><td>36.37</td><td>0.200</td><td>0.500</td><td>0.900</td><td>1</td><td></td><td>LN</td></tr><tr><td>LSUN-BEDROOM</td><td>70.30</td><td>48.88</td><td>1.000</td><td>0.500</td><td>0.999</td><td>1</td><td></td><td>SN</td></tr><tr><td>LSUN-BEDROOM</td><td>73.84</td><td>60.54</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>-</td><td>SN</td></tr><tr><td>CELEBA-HQ-128</td><td>29.13</td><td>=</td><td>0.100</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>LN+DR</td></tr><tr><td>CELEBA-HQ-128</td><td>29.65</td><td></td><td>0.200</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>GP</td></tr><tr><td>LSUN-BEDROOM</td><td>55.72</td><td></td><td>0.200</td><td>0.500</td><td>0.900</td><td>5</td><td>1</td><td>LN+GP</td></tr><tr><td>LSUN-BEDROOM</td><td>57.81</td><td></td><td>0.100</td><td>0.500</td><td>0.999</td><td>1</td><td>10</td><td>SN+GP</td></tr></table>",
+        "bbox": [
+            173,
+            458,
+            830,
+            666
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F WHICH PARAMETERS REALLY MATTER? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            539,
+            707
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For each architecture and hyper-parameter we estimate its impact on the final FID. Figure 11 presents heatmaps for hyperparameters, namely the learning rate, $\\beta _ { 1 }$ , $\\beta _ { 2 }$ , $n _ { d i s c }$ , and $\\lambda$ for each combination of neural architecture and data set. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            760
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G VARIATIONS OF MS-SSIM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            780,
+            433,
+            796
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We used the MS-SSIM scorer from TensorFlow with default power factors (Wang et al., 2003). Note that the default filter size for each scale layer is 11, the minimum image edge is $1 1 \\times 2 ^ { 4 } = 1 7 6$ . To adapt it to CELEBA-HQ-128 data set with size $1 2 8 \\times 1 2 8$ , we used the minimum of filter size 11 and image size in last scale layer to allow the computation followed the previous work (Fedus et al., 2018). ",
+        "bbox": [
+            174,
+            810,
+            825,
+            861
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/a620c819b77783ecdf835e2bca26b7daa21ab98c620a817c509721f93bec312c.jpg",
+        "table_caption": [
+            "Table 9: ResNet CIFAR parameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DATA SET</td><td>MEDIAN</td><td>BEST</td><td>LR(×10-3)</td><td>β1</td><td>阳</td><td>ndisc</td><td>入</td><td>NORM</td></tr><tr><td>CIFAR10</td><td>31.40</td><td>28.12</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>=</td></tr><tr><td>CIFAR10</td><td>33.79</td><td>30.08</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>1</td></tr><tr><td>CIFAR10</td><td>23.57</td><td>22.91</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>=</td><td>SN</td></tr><tr><td>CIFAR10</td><td>25.50</td><td>24.21</td><td>0.100</td><td>0.500</td><td>0.999</td><td>5</td><td>1</td><td>SN</td></tr><tr><td>CIFAR10</td><td>22.98</td><td>22.73</td><td>0.200</td><td>0.500</td><td>0.999</td><td>1</td><td>1</td><td>SN+GP</td></tr><tr><td>CIFAR10</td><td>23.57</td><td>22.91</td><td>0.200</td><td>0.500</td><td>0.999</td><td>5</td><td>-</td><td>SN</td></tr></table>",
+        "bbox": [
+            199,
+            128,
+            794,
+            253
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c414c042d882f1159a23063a0813130967a1b2a1edd717e9194cf65a2038b5d.jpg",
+        "image_caption": [
+            "Figure 8: Examples generated by GANs on CELEBA-HQ-128 data set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            266,
+            815,
+            449
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/786ca8fc171e60cd0ce2ba0004d5703869c528cf8d62a05307aaaa0a46d3dac5.jpg",
+        "image_caption": [
+            "Figure 9: Examples generated by GANs on LSUN-BEDROOM data set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            488,
+            815,
+            670
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/f1aa1099a3ce5eda2019dddd846b6c2bcea9f181181c9afb1322704faf348863.jpg",
+        "image_caption": [
+            "Figure 10: Examples generated by GANs on CIFAR10 data set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            709,
+            815,
+            892
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d088858e2c8a8cdce82899931934b317604f9bbc30cf7186dc9ab1f5de9f6026.jpg",
+        "image_caption": [
+            "(a) FID score of SNDCGAN on CIFAR10 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            156,
+            826,
+            253
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a4b30b761160941966aad9cf0ab6d3e235aa2b161986758303f170b1a6c47ad.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            272,
+            826,
+            366
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fdffed4172209843481fb9fb7c89d573d4d072037af4106b0d06c88c8ffef4a.jpg",
+        "image_caption": [
+            "(b) FID score of SNDCGAN on CELEBA-HQ-128 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            385,
+            826,
+            478
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/caca60a47d429ab4c4922f440ad3bcacb75f73720679a37c1f0fc45fed5e22fe.jpg",
+        "image_caption": [
+            "(c) FID score of SNDCGAN on LSUN-BEDROOM "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            498,
+            825,
+            593
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab454109195ada56fe60611674239d53e1ad36fe16717cd09a8e2e4b60b42140.jpg",
+        "image_caption": [
+            "(d) FID score of ResNet CIFAR on CIFAR10 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            612,
+            826,
+            705
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ccd750f16de1b8efe3bdfea4b323d33e40ae824119fbb2a87ae4ec00eee859d8.jpg",
+        "image_caption": [
+            "(e) FID score of ResNet19 on CELEBA-HQ-128 ",
+            "Figure 11: Heat plots for hyper-parameters on each architecture and dataset combination. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            724,
+            826,
+            838
+        ],
+        "page_idx": 16
+    }
+]