Add files using upload-large-folder tool

parse/dev/3tbTw2ga8K/3tbTw2ga8K.md

@@ -0,0 +1,325 @@
+# The Quantization Model of Neural Scaling
+
+Eric J. Michaud∗, Ziming Liu, Uzay Girit, and Max Tegmark MIT & IAIFI
+
+# Abstract
+
+We propose the Quantization Model of neural scaling laws, explaining both the observed power law dropoff of loss with model and data size, and also the sudden emergence of new capabilities with scale. We derive this model from what we call the Quantization Hypothesis, where network knowledge and skills are “quantized” into discrete chunks (quanta). We show that when quanta are learned in order of decreasing use frequency, then a power law in use frequencies explains observed power law scaling of loss. We validate this prediction on toy datasets, then study how scaling curves decompose for large language models. Using language model gradients, we automatically decompose model behavior into a diverse set of skills (quanta). We tentatively find that the frequency at which these quanta are used in the training distribution roughly follows a power law corresponding with the empirical scaling exponent for language models, a prediction of our theory.2
+
+# 1 Introduction
+
+In the aggregate, larger neural networks trained on more data perform better than smaller neural networks trained on less data, in a predictable way. Across a range of studies, mean test loss has been observed to decrease as a power law in both the number of network parameters $( L \propto N ^ { - \alpha _ { N } } )$ ) and the number of training samples $( L \propto D ^ { - \alpha _ { D } }$ ) [1, 2, 3, 4, 5, 6, 7]. Although aggregate performance changes smoothly with scale, when particular capabilities are examined, larger models often have emergent abilities, i.e., qualitatively different performance than smaller models [8, 9]. Understanding and reconciling both facets of scaling – the predictable power law decrease in loss and the emergence of new capabilities at scale – is of both theoretical and practical interest [10]. Understanding how scaling changes what neural networks learn is entangled with core questions: what are deep neural networks doing internally, and will they will continue to improve with scale?
+
+Recent studies of the internals of neural networks have found a variety of impressive algorithms learned by gradient descent [11, 12, 13, 14, 15]. As more work is put into understanding the structures learned by neural networks (the task of mechanistic interpretability), we may find more and more circuits [11, 16] in models, intelligible internal algorithms for accomplishing prediction in specific contexts. Can such analysis be scaled up to frontier models [17]? Two assumptions which, if true, would make us more optimistic about mechanistically understanding large models include (1) decomposability/modularity/sparsity [18, 19, 20, 21] – that large models are decomposable into parts, and only a small number of these parts are relevant to the model’s behavior on any given sample and (2) universality [22, 11, 23, 24] – that similar structures recur across models of increasing size. Recently, Olsson et al. [25] found encouraging evidence for universality of “induction heads” across LLMs and found that these emerge in a discrete transition during training.
+
+In this paper, we articulate the Quantization Hypothesis, a set of informal conjectures about the decomposability of networks into smaller parts, the universality of computations performed across model scales, the discreteness of what models learn, and about how properties of the data distribution produce power law neural scaling. In particular, we hypothesize that to many prediction problems, there corresponds a particular enumerable set of indivisible pieces of knowledge or skills that models must learn, and that model performance is determined by which of these elements models successfully learn. We call these basic building blocks of model performance the quanta:
+
+![](images/2f11df327f2f1eb2f37c0b561391ddc7f40e679a8600518383828d3d685a6a30.jpg)  
+Figure 1: We auto-discover quanta – basic units of model knowledge/skill – for a language model. Here we show collections of next-token prediction samples which our method clustered together, each corresponding to some coherent model behavior. We indicate the token which was predicted from the context before it with a red highlight. We indicate newlines using $\ " \mathrm { \Omega } ^ { 6 6 } \mathrm { \Omega } \backslash \underline { { \mathrm { \Omega } } } \mathrm { \Omega } \mathrm { \Omega }$ . See Section 5 for explanation.
+
+Quantum (plural quanta): An indivisible computational module that, for example, retrieves a fact, implements an algorithm, or more generally corresponds to some basic skill possessed by a model.
+
+We use this terminology in analogy to Max Planck’s assumption in 1900 that energy is quantized into discrete chunks (quanta) – here we imagine that knowledge/skills are quantized into discrete chunks (quanta). Since “quantization” is commonly used in machine learning in the context of low-precision arithmetic, we suggest “knowledge quantization��� or “skill quantization” to refer to our notion of quantization. We will see that a Zipfian distribution governing the “use frequency” of the quanta produces power law neural scaling, where the effect of scaling is to learn an increasing number of discrete quanta, and smooth scaling laws average over small discrete jumps in model performance.
+
+This paper is organized as follows: in Section 2 we give a theoretical model of power law neural scaling from the Quantization Hypothesis. In Section 3 we construct toy datasets satisfying the hypothesis, where smooth power laws average over many discrete jumps in model performance. In Section 4 we then analyze how power law scaling decomposes for real LLMs. In Section 5, we develop a method for automatically discovering quanta in language models by clustering their behavior into basic coherent skills, and analyze the statistics of these clusters, concluding in Section 7.
+
+# 2 Theory
+
+Consider the task of modeling the distribution of text on the internet. Successful prediction requires an immense amount of knowledge, and the ability to perform diverse computations, due to the immense complexity and diversity of the world and therefore of human language. For instance, in order to predict what word will come next in a conversation between two physicists, one must “know” much about physics. In order to continue the text $^ { \cdot \cdot } 2 5 3 4 ~ + ~ 7 2 6 1 ~ = ~ ^ { \cdot \cdot }$ , one must be able to perform arithmetic (for large enough numbers, memorization becomes a highly inefficient strategy) [26]. A great many distinct types of computations are present in the world in the processes that produce text, and so predicting text requires those computations to be present in our models.
+
+In this paper, we conjecture the Quantization (or Quanta) Hypothesis:
+
+QH1 Many natural prediction problems decompose into an enumerable set of computations, pieces of knowledge, or skills, which models must learn to reduce loss. We call these quanta, and model them as being discrete, – they are either learned or not learned. Model performance is determined by which quanta have been learned.
+
+QH2 Some quanta are more useful for reducing loss than others, leading to a natural ordering of the quanta. We call the ordered quanta the Q Sequence. Optimally trained networks should therefore learn the quanta in that order. The effect of scaling is to learn more of the quanta in the Q Sequence, so scaling performance is simply determined by how many quanta are successfully learned.
+
+QH3 The frequencies at which the quanta are used for prediction follow a power law.
+
+Together these can result in power law neural scaling. We model the Quantization Hypothesis as follows, referring to the below as the “Quantization (or Quanta) Model”. Let q denote a bit string whose $k ^ { \mathrm { t h } }$ bit $\mathbf { q } _ { k } = 1$ if the $k ^ { \mathrm { t h } }$ quantum in the Q Sequence has been learned, and $\mathbf { q } _ { k } = 0$ otherwise. QH1 implies that the mean loss $L$ is simply a function of $\mathbf { q }$ . QH2 implies that when $n \equiv \textstyle \sum _ { k } \mathbf { q } _ { k }$ quanta have been learned, we have $\mathbf { q } _ { k } = 1$ for $k \leq n$ . Let $L _ { n }$ denote the mean loss in this case. From QH3, we have that the $k ^ { \mathrm { t h } }$ quantum benefits prediction on a randomly chosen sample with probability
+
+$$
+p _ { k } = \frac { 1 } { \zeta ( \alpha + 1 ) } k ^ { - ( \alpha + 1 ) } \propto k ^ { - ( \alpha + 1 ) }
+$$
+
+for a Zipf power law α > 0, where ζ(s) ≡ P∞k=1 k−s. Let us also assume that learning the kth where it is utilized. If $a _ { k }$ and $b _ { k }$ are $k$ -independent $\mathit { a } _ { k } = { a } , { b } _ { k } = { b } )$ , then a model that has learned the first $n$ quanta will have expected loss
+
+$$
+\begin{array} { r c l } { { { \cal L } _ { n } } } & { { = } } & { { \displaystyle \sum _ { k = 1 } ^ { n } a p _ { k } + \sum _ { k = n + 1 } ^ { \infty } b p _ { k } = \sum _ { k = 1 } ^ { \infty } a p _ { k } + \sum _ { k = n + 1 } ^ { \infty } ( b - a ) p _ { k } } } \\ { { } } & { { \approx } } & { { \displaystyle a + \frac { b - a } { \zeta ( \alpha + 1 ) } \int _ { n } ^ { \infty } k ^ { - ( \alpha + 1 ) } d k = a + \frac { b - a } { \alpha \zeta ( \alpha + 1 ) } n ^ { - \alpha } . } } \end{array}
+$$
+
+In other words, $L _ { \infty } = a$ and $\left( L _ { n } - L _ { \infty } \right) \propto n ^ { - \alpha }$ is a power law.
+
+In Appendix A, we provide analogous derivations for other assumptions for $a _ { k }$ and $b _ { k }$ , and find that a range of assumptions produce curves that are exact or approximate power laws – the latter include a small logarithmic correction.
+
+In the derivation above, we assumed that all samples are what we will refer to as monogenic, meaning that prediction relies on at most a single quantum, akin to how monogenic traits in biology (e.g. cystic fibrosis) depend on a single gene. By assuming that all samples are monogenic, we can write the expected loss as a sum over quanta, weighted by the fraction of samples which rely on that quanta $p _ { k }$ . We further explore the idea of monogenic vs. polygenic samples in Section 4.2. So far we have seen how the Quantization Hypothesis can produce power law scaling as a function of the number of quanta learned $n$ . We will now give one possible mechanism by which this can translate into power law scaling in parameters, data, etc.:
+
+Parameter scaling: In networks of finite size, network capacity can bottleneck how many quanta are learned. If we assume that all quanta require the same capacity of $C$ network parameters, then a network with $N$ parameters can learn roughly $n \approx N / C$ quanta. Therefore $L ( N ) - L _ { \infty } \propto n ^ { - \alpha } \approx$ $( N / C ) ^ { - \alpha } \propto N ^ { - \mathrm { \tilde { \alpha } } }$ , we so we get power law scaling in $N$ with exponent $\alpha _ { N } = \alpha$ .
+
+Data scaling (multi-epoch): For data scaling, we assume that for each quantum, a threshold of $\tau$ examples utilizing quantum $k$ are needed in the training set for quantum $k$ to be learned3. With $D$ training samples, approximately $D p _ { k }$ samples relying on quantum $k$ will be present, and solving for $D p _ { n } = \tau$ we get the last quantum to be learned will be $\bar { n } \propto ( D / \tau ) ^ { 1 / ( \alpha + 1 ) }$ since $p _ { k } \propto k ^ { - ( \alpha + 1 ) }$ Under this model, we get scaling in data samples $L ( D ) - L _ { \infty } \propto n ^ { - \alpha } \propto \left( D / \tau \right) ) ^ { - \alpha / \left( \alpha + 1 \right) } \propto$ $D ^ { - \alpha / ( \alpha + 1 ) }$ , and so $\alpha _ { D } = \alpha / ( \alpha + 1 )$ . From our earlier result that $\alpha _ { N } = \alpha$ , we would therefore predict that $\alpha _ { D } = \alpha _ { N } / ( \alpha _ { N } + 1 )$ . We discuss whether this relationship holds empirically for data and parameter scaling exponents observed across a variety of studies in Appendix F.
+
+Data scaling (single-epoch): In multi-epoch training, the information contained in the training dataset can bottleneck which quanta are learned. However, the rate of convergence of SGD can also bottleneck performance. For single-epoch training, a greater number of training samples allows one to train for longer. In our model, the amount that each quantum reduces mean loss by follows a power law. If the magnitude of the gradients for learning these quanta also follow a power law, then the convergence time for each quanta may follow a power law too. If the number of steps to learn quantum $k$ is $\propto 1 / p _ { k }$ , then if the first quantum requires $T$ steps to be learned, quantum $n$ will require $T n ^ { \alpha + 1 }$ steps, and so $n = ( S / T ) ^ { 1 / ( \alpha + 1 ) }$ quanta can be learned in $S$ steps. This gives scaling in training steps $L ( S ) - L _ { \infty } \propto n ^ { - \alpha } \approx ( S / T ) ^ { - \alpha / ( \alpha + 1 ) } \propto S ^ { - \alpha / ( \alpha + 1 ) }$ , and so $\alpha _ { S } = \alpha / ( \alpha + 1 )$ . Under this model, multi-epoch and single-epoch data scaling exponents coincide: $\alpha _ { D } = \alpha _ { S }$ .
+
+# 3 Proof of concept: a toy dataset
+
+In this section, we will describe a toy dataset consisting of distinct subtasks which are power law distributed in frequency. We observe power law neural scaling in data and parameters on this task, and find that the mechanism of neural scaling coincides with our theory from Section 2. It is therefore possible for scaling laws to arise from the Quantization Model for data with the right structure. We leave a study of whether natural datasets (e.g. natural modeling) possess such structure to Section 4.
+
+# 3.1 The “multitask sparse parity” dataset
+
+The toy task we will construct consists of many subtasks – distinct types of inputs which each require corresponding distinct computations (quanta). For each subtask, we choose a variant of the “sparse parity” problem, recently studied in [28]. The sparse parity prediction problem is simple: given a bit string of length $n$ , compute the parity (sum mod 2) of a fixed subset of $k$ of those bits. We introduce an extension of this task, which we call “multitask sparse parity”. Beyond $n$ and $k$ , multitask sparse parity adds an additional parameter $n _ { \mathrm { t a s k s } }$ , the number of subtasks (number of distinct versions of sparse parity) present in the dataset. To construct the task, we first choose $n _ { \mathrm { t a s k s } }$ random subsets $S _ { i }$ of $k$ indices from $\{ 1 , 2 , \ldots , n \}$ : $S _ { i } \subset \{ 1 , 2 , . . . , n \}$ and $| S _ { i } | = k$ , where $i = 1 , 2 , \dots , n _ { \mathrm { t a s k s } }$ . Input bit strings are length $n _ { \mathrm { t a s k s } } + n$ . We call the first $n _ { \mathrm { t a s k s } }$ bits the control bits and the last $n$ bits the task bits. If control bit $i$ is active, then the parity is computed from the subset $S _ { i }$ of the task bits. The control bits 1-hot encode the task number: on a given input, only one control bit is set to 1 at a time – the rest are zero. For the sample shown below, since control bit 2 is active, the answer is the parity of the task bits $S _ { 2 } = \{ 2 , 7 \}$ , which is 0 for this input:
+
+![](images/8fe39dd784a5fd64c34b6d489cea0f0ffe96afc31027c86d0d7ffaa5c3f48bf0.jpg)
+
+![](images/ddd83df76e992c57c504daecbaa2710574c3087aaf7aee780b094adbbba1a961.jpg)  
+Figure 2: Top: Neural networks exhibit power law scaling in loss w.r.t. parameters $N$ , training time $S$ , and training samples $D$ (for multi-epoch training) when trained on the multitask sparse parity dataset. Here $\alpha = 0 . 4$ and we plot lines $\propto N ^ { - \alpha }$ , $\stackrel { \cdot } { \propto } S ^ { - \alpha / ( \alpha + 1 ) }$ , $\propto D ^ { - \alpha / ( \alpha + 1 ) }$ . Bottom: neural scaling broken down by subtask. Scaling behavior on individual subtasks exhibits emergence, where subtasks are suddenly learned above a particular scale. Power law neural scaling of mean test loss averages over a large number of qualitative changes in network performance (when broken down by subtask), with loss being driven to zero on an increasing number of subtasks which are power law distributed in frequency, a realization of the mechanism of neural scaling discussed in Section 2.
+
+We impose a uniform distribution over the task bits. On the control bits, we impose a Zipfian distribution: the probability that a sample has control bit $i$ active (and therefore the parity must be computed from the subset $S _ { i }$ of the task bits) is ${ \scriptstyle { \frac { 1 } { Z } } } i ^ { - ( \alpha + 1 ) }$ where $\begin{array} { r } { Z = \sum _ { i = 1 } ^ { n _ { \mathrm { t a s k s } } } i ^ { - ( \alpha + 1 ) } } \end{array}$ . This imposes a power law distribution over subtasks in data. Since answers are parities, this task can be treated as a binary classification problem on the subset of bit strings $\{ 0 , 1 \} ^ { \bar { n _ { \mathrm { t a s k s } } } + n }$ where for each string all but one bit of the first $n _ { \mathrm { t a s k s } }$ bits are zero.
+
+# 3.2 Power law scaling and emergence
+
+We train ReLU MLPs with a single hidden layer to solve this task with cross-entropy loss. The input dimension is $n _ { \mathrm { t a s k s } } + n$ . We use the Adam optimizer with a learning rate of $1 0 ^ { - 3 }$ . To study scaling with respect to the number of model parameters, we train networks of varying width by sampling batches online. Within an individual single-epoch training run, we can study scaling in steps $S$ . To study scaling with respect to multi-epoch training dataset size $D$ , we use a network of sufficient width for capacity to not be a bottleneck, and for varying $D$ we sample a training set of $D$ samples and train for multiple epochs, recording model performance when mean test loss is lowest (early-stopping).
+
+Training dynamics on the multitask sparse parity problem are highly nontrivial – on each individual subtask, loss follows a reverse-S curve, dropping after an initial plateau. This transition happens at different times for different subtasks, so the overall loss decreases smoothly, averaging over these transitions. See Appendix B for more discussion of training dynamics.
+
+Figure 2 shows scaling curves on the multitask sparse parity problem. For the results shown, we used $n _ { \mathrm { t a s k s } } = 5 0 0$ , $n = 1 0 0$ , $k = 3$ , $\alpha = 0 . 4$ , and a batch size of 20000. We vary training dataset size from 1e4 to 5e6 and vary hidden-layer width from 10 to 500 neurons. We train for 2e5 steps. In line with the theory from Section 2, we find that as we scale training data and parameters, networks learn more and more quanta (reducing loss on more and more subtasks), roughly in order of their frequency, and that this is what drives neural scaling. We see that scaling w.r.t. parameters is noisier than data scaling, possibly due to model initialization having some influence on which quanta are learned (for our data scaling experiments, we use the same seed and same model size for all runs). We also see that for scaling on individual subtasks, there is a rough scale of data or parameters below which networks do not learn the task, and above which they do. Smooth power law scaling therefore averages over a large number of emergent changes in model performance when properly decomposed by subtask, a proof of concept that the Quantization Model can be the mechanism of neural scaling for data with the right structure. See Appendix B for additional results and discussion on how the scaling exponents $\alpha _ { N } , \alpha _ { S } , \alpha _ { D }$ relate to the subtask distribution power law exponent $\alpha + 1$ empirically.
+
+![](images/3d3434ac3cf299c84c699843eb692aaaaf2872958300c1cf1dc2675a3c3ff648.jpg)  
+Figure 3: Left: Scaling of mean test loss w.r.t. non-embedding parameters for the Pythia models [29]. The parameter scaling exponent $\alpha _ { N }$ is measured to be $\approx 0 . 0 8 3$ from the first six points along the curve (the seventh model appears to break the trend). Center: the distribution $p ( L )$ over losses on individual samples for models of different size. Losses $\approx 0$ are by far the most common, and larger models achieve $\approx 0$ loss on an increasing fraction of samples. Right: the expected loss integrand $L p ( L )$ for models of different sizes. Low-loss samples contribute minimal mass to the mean loss, which is instead dominated by samples with much higher loss of 5-10 bits (depending on scale).
+
+# 4 Decomposing LLM scaling laws
+
+We now study how scaling curves for large language models decompose. For our experiments, we use the Pythia model suite from Eleuther AI [29], a set of decoder-only transformers of varying size trained on approximately 300 billion tokens of The Pile [30]. We evaluate several models in the suite (ranging from $1 9 \mathrm m$ to $6 . 4 \mathrm { b }$ non-embedding parameters) on approximately 10 million tokens from the test set of The Pile. We record cross-entropy loss on every token, enabling us to study how loss on individual tokens, as well as how the distribution over losses, changes with model scale.
+
+# 4.1 The distribution over per-token losses
+
+In Figure 3, we show how the distribution over losses scales with model size. First, we find that for the first six models in the Pythia sequence, the mean loss scales as a power law with exponent $\alpha _ { N } = 0 . 0 8 3$ , roughly in line with the parameter scaling exponent of 0.076 measured in [3]. The 6.4b model does not fit the scaling curve well, so we excluded its loss when measuring the scaling exponent. Next, we plot the probability distribution over per-token losses $p ( L )$ . We find that losses close to zero are by far the most common, and that scaling increases the portion of approximately-zero losses. We also plot $L p ( L )$ , the probability density over losses weighted by loss. The mean loss is the area under this curve. We see that despite approximately-zero-loss tokens being by far the most common, they do not contribute much mass to the mean loss. See Figure 11 for how these distributions change over training steps rather than across model size. We note that neural scaling in the wild is much more complicated than for multitask sparse parity – notably, the distribution over losses is not bimodal. We leave a detailed study of whether the statistics of neural scaling in LLMs are compatible with prior models of neural scaling to future work.
+
+![](images/c5d2619de5a665c3ca98081ff4ce4d3bfaac45f7b76c3016fa0ef366ea36ca85.jpg)  
+Figure 4: Per-sample scaling curves can have diverse behavior. Here we show extreme examples where scaling (of loss on predicting the highlighted token) is abrupt versus smooth. If the Quantization Hypothesis describes language modeling, then samples with sharp scaling would be monogenic, displaying sharp emergence at a particular model scale when the relevant quantum is learned. Samples with gradual scaling would be polygenic, where many quanta, emerging at different scales, marginally improve the loss. We show additional examples in Figure 12.
+
+# 4.2 Monogenic versus polygenic scaling curves
+
+In our introduction of the Quantization Hypothesis in Section 2 and our multitask sparse parity study in Section 3 we modeled network performance on individual samples as benefitting from a single quantum – all samples belong to a single subtask, which is either solved or not solved in a binary fashion. In our model and on multitask sparse parity, scaling curves on individual examples all exhibit emergence – loss on individual examples undergoes a sharp transition at a particular scale of parameters or data. Do we observe this in large language models?
+
+Inspecting a large number of per-token (per-sample) scaling curves, we observe a variety of scaling behaviors. On some samples, loss drops at a particular scale. More typically though, loss improves at multiple scales. If the Quantization Hypothesis is true and the effect of scaling is to simply add new quanta to the model, then for per-sample loss curves to show progress at multiple scales, those samples must benefit from multiple quanta additively. As first mentioned in Section 2, we borrow terminology from genetics and refer to prediction problems for which the model’s performance is determined by a single quantum as monogenic (akin to when a single gene determines a trait) and as polygenic when multiple quanta influence performance (in analogy to when multiple genes contribute to a trait). In multitask sparse parity, all prediction problems are monogenic. In natural language, we observe that model performance on most tokens improves at multiple scales, suggesting that most tokens are polygenic, but we can find tokens for which loss drops as a single phase transition in scale. Polygenicity forms a spectrum: the smoothness of the loss curve can vary substantially between examples, presumably with some prediction problems using few quanta and others using many. In Figure 4, we show extreme examples of both monogenic and polygenic samples.
+
+Note that our monogenic/polygenic taxonomy of model behaviors assumes that QH1 and QH2 are true. However, it could be the case that there isn’t an underlying discreteness to what is learned, or that scaling totally changes what networks learn, rather than simply adding additional quanta. Whether scaling truly has the effect we described will have to be investigated in future studies of the internals of neural networks. We also note that it is possible that sharp transitions in the per-token loss curves could be due to noise – if we had multiple runs with different random seeds for each model scale, we could better test whether the mean loss across seeds decreases smoothly or if there is a genuine discreteness where gradual progress is impossible for apparently “monogenic” tokens.
+
+# 5 The quanta of language modeling
+
+We have conjectured that the internals and behavior of language models are decomposable into an enumerable set of modules and associated skills (quanta). What might these basic building blocks of LLMs be? In this section, we develop a preliminary method to discover quanta. In particular, we will attempt to cluster tokens in a language corpus according to what knowledge or skill LLMs use to predict those tokens from their context. Our goal is to find coherent clusters of language model behavior that each reveal some distinct skill that the model has learned. Note that in clustering tokens to discover quanta, we are making the likely unrealistic assumption that these tokens are monogenic – that there is only one quantum involved in predicting each token. Not also that these clusters of behavior will not give us a mechanistic understanding of the quanta, but simply provide examples of LLM skills which could be studied further in future work.
+
+We propose the use of gradients to cluster next-token prediction samples, where a “sample” consists of a token and its context in some document. Given some model, we will cluster two samples together if the gradient of the model’s loss on each sample w.r.t. the model’s parameters is similar for the two samples. The intuition for using gradients is as follows: if a model uses the same internal module to generate its prediction on two samples, then the gradients for parameters within the module may be nonzero and similar for the two samples (and possibly $\approx 0$ for parameters in irrelevant modules). If a model uses different modules to generate its prediction on different samples, then the gradients may not overlap. We therefore use gradient similarity as a proxy for mechanistic similarity – whether a model uses similar mechanisms/modules to generate its prediction on distinct samples. While crude, we find that gradients contain enough information to allow us to automatically discover many coherent clusters of LLM behavior using the following algorithm:
+
+Quanta Discovery from Gradients (QDG): We will use spectral clustering on gradients to find clusters of samples whose gradient has nonzero cosine similarity. Given a set of samples $( x _ { i } , y _ { i } )$ and a model $f _ { \theta }$ , we compute gradients for each sample $g _ { i } = \nabla _ { \theta } \dot { L } ( f _ { \theta } ( x _ { i } ) , y _ { i } )$ . We then normalize these gradients $g _ { i } \mapsto { \hat { g } } _ { i }$ so that ${ \hat { g } } _ { i } \cdot { \hat { g } } _ { i } = 1$ . Let $A$ be a matrix whose rows are the normalized gradients: $A _ { i , \cdot } = \hat { g } _ { i }$ . If we are clustering $d$ samples and our model has $n$ parameters, $A$ has shape $( d , n )$ . We compute an affinity matrix $C = A A ^ { T }$ , a matrix of shape $( d , d )$ where $C _ { i j } = \hat { g } _ { i } \cdot \hat { g } _ { j }$ , the cosine similarity between gradients $g _ { i } , g _ { j }$ . From this, we compute an affinity matrix of the angular similarities $\hat { C }$ (which take values in $[ 0 , 1 ] )$ via $\begin{array} { r } { \hat { C } _ { i j } = 1 - \operatorname { a r c c o s } ( C _ { i j } ) / \pi } \end{array}$ . We then perform spectral clustering with $\hat { C }$ to cluster samples.
+
+QDG is expensive to compute for large models and for large numbers of samples. We therefore only apply it to the smallest model in the Pythia suite, which has $1 9 \mathrm m$ non-embedding parameters. We cluster 10000 tokens on which this model is confident and correct in its prediction, achieving less than 0.1 nats of cross-entropy. See Appendix C.1 for more detail.
+
+We find that many, though not all, QDG clusters reveal some coherent model behavior. We show examples from clusters in Figure 1 and Figure 13. These clusters were found with the spectral clustering hyperparameter n_clusters $= ~ 4 0 0$ . While most clusters involve the prediction of the same token, manually inspecting these clusters we find that they usually involve predicting the same token for a coherent reason, rather than being based merely on having the same output. We also find clusters for more abstract prediction rules. For instance, the quantum shown on the left column of Figure 1 is the skill of incrementing a numerical sequence, and the examples involve predicting a variety of different tokens representing numbers.
+
+# 5.1 The natural distribution over language modeling quanta
+
+In our model, some quanta are more frequently used than others. If these frequencies follow a power law in accordance with the Quantization Hypothesis, then we may expect QDG cluster sizes to be governed by a power law. The measured scaling exponent of $\alpha _ { N } = 0 . 0 8 3$ from Figure 3 implies a power law distribution over quanta with exponent $- 1 . 0 8 3$ . Do the cluster sizes follow this?
+
+Figure 5 shows rank-frequency curves for clusters discovered with QDG for varying choices of n_clusters. These curves sort the clusters according to their size and then plot size against cluster index (rank). We plot rank-frequency curves for many choices of n_clusters since it is unclear a priori which n_clusters to use. When we measure the slope of the rank-frequency curve, we measure it from the envelope formed by the many rank-frequency curves, a practice which we discuss in Appendix E. Biases in the clustering algorithm and inherent noise in model gradients make clustering imperfect, and lead to high uncertainty of our the measured power law exponent. From our analysis in Appendix E, we think that extracting the power law exponent over quanta utilization frequency by measuring the slope of the rank-frequency curve should have uncertainty of at least 0.2. We also note that some rank-frequency curves don’t look like a clean power law. In Appendix E, Figure 16 we find that we can get similar-looking curves in a toy model of this clustering process when the dimension and noise is high. Between ranks 100-1000, we measure a slope of $\approx - 1 . 2 4$ , about 0.16 off our expected slope of $- 1 . 0 8$ , and so within the margin of error. We are encouraged that the size of our discovered clusters seem to decay at a rate (very roughly) compatible with observed neural scaling exponents, in line with our theory. However, less naive clustering schemes, operating on more samples with more clusters, could be useful to sharpen this measurement.
+
+![](images/5ad69ee70ac52f7652d0d5003acf5f27693fad7bbfd4e571814f9140e0c62826.jpg)  
+Figure 5: Left: angular similarity between model gradients for a variety of natural language samples. Samples are reordered according to their QDG cluster (with 400 clusters) to reveal the block-diagonal structure of the similarity matrix. We visualize a small part of the overall similarity matrix in this plot – note that not all clusters are as visibly distinct as the ones shown. Right: rank-frequency plot of QDG clusters. We measure the slope of the envelope of the rank-frequency curves from cluster rank 100-1000 to be $\approx - 1 . 2 4$ , which is a steeper than the slope of -1.08 expected from the measured parameter-scaling exponent from Figure 3, though within the margin of error given the uncertainty of our clustering methodology. See Appendix E for a discussion of the bias/uncertainty of our method.
+
+# 6 Related Work
+
+Models of neural scaling: Several models of neural scaling laws have been proposed in prior work. Sharma and Kaplan [31] explain power law scaling w.r.t. model parameters using an argument from approximation theory, which relates neural scaling exponents to the dimension of the data manifold $d$ . Michaud et al. [32] point out that effective dimension $d$ could be generalized to the maximum arity of the target function’s computation graph for sparse compositional problems. Bahri et al. [33] generalized the model of Sharma and Kaplan [31] to scaling w.r.t. dataset size, additionally relating scaling exponents to the power law spectrum of certain kernels. Maloney et al. [34] develop an exactly solvable random-feature model of scaling, from which they derive a joint parameter-data scaling law. Bordelon et al. [35] develop a model of data scaling for kernels, decomposing the generalization error into a sum over eigenmodes, whereas we decompose error into a sum over quanta. Arguably the closest prior work to ours is Hutter [36], who develops a model of data scaling wherein a discrete set of “features” must be learned. In this model, a feature is learned if it occurs at least once in the training set. If the features are Zipfian distributed, this produces power law scaling in expectation but with high variance. In our model, using a data threshold $\tau \gg 1$ lowers the variance in the scaling curve, and we also considered scaling w.r.t. parameters and applied the model to real networks.
+
+Understanding emergent abilities: Wei et al. [8] and Srivastava et al. [37] document examples of emergent abilities in large language models, though Schaeffer et al. [38] suggest that these examples are an artifact of the metric used to evaluate performance. Arora and Goyal [39] develop a framework for the emergence of “skills”, where predicting text requires combining multiple different skills from an underlying set of language skills.
+
+Miscellaneous: The topic of phase transitions in machine learning is not new [40], but our work was strongly influenced by the recent work of Olsson et al. [25] who observe a phase change from the formation of induction heads and especially Nanda et al. [13] who conjecture that phase changes may be ubiquitous. Simon et al. [41] also exhibit a task where learning proceeds as a series of discrete steps. Chen et al. [42] develop a framework for understanding LLM “skills” in a hierarchy and for choosing data to more efficiently learn desired skills. Chan et al. [43] study how a Zipfian data distribution influences in-context learning.
+
+# 7 Discussion
+
+Summary: The Quantization Hypothesis posits that for some types of prediction problems, models must learn a discrete (quantized) set of modules/knowledge/skills (quanta). When data is distributed in such a way that the “use frequencies” of these quanta follow a power law, then power law neural scaling can arise as models learn more and more quanta, with smooth scaling curves averaging over many small cases of emergence. We presented a toy dataset where neural scaling exhibits these properties. We then documented how language model scaling curves decompose, beyond simply how the mean loss scales. Lastly, we developed a method to discover quanta from the internal structure of trained models, from which we were able to enumerate a large number of skills of a small language model. The frequencies at which the quanta we discover are used for prediction in natural text seem to roughly track the power law our theory would predict, though this measurement is quite imprecise.
+
+Limitations: While the Quantization Hypothesis appears to hold for our toy datasets, much work remains in investigating to what extent it holds for natural tasks like language modeling. Probably our riskiest assumption was that there is an underlying discreteness to everything that models learn. Gradual scaling seems typical in LLMs [38], and it could be more parsimonious to model neural scaling as an underlying smooth process rather than to assume that most tasks are highly polygenic with underlying discrete quanta. Note also that in our model of scaling w.r.t. parameters $N$ , having more parameters merely increases the capacity of the network. In practice however, larger networks are more efficient learners [7], and one can trade off between parameters and data, whereas in our model parameters and data independently bottleneck the number of quanta that can be learned. Additionally, we modeled the quanta as being independent, where learning order is given just by the use frequencies, but it could make more sense to think of the quanta as living in a hierarchical dependency graph. Lastly, our QDG method is neither very principled nor scalable, and much better methods could likely be developed to discover quanta and study their statistics for larger models and across more samples.
+
+Implications for emergence and forecasting: Srivastava et al. [37] find that on some tasks, neural scaling has high “linearity”, with gradual improvements to scale, with other tasks displaying “breakthroughness”, where performance improves sharply at some scale. In our model, high linearly would result from a task’s relevant quanta being widely spread along the Q Sequence, and high breakthroughness would result from a task being monogenic or from the relevant quanta being close together in the Q Sequence. Our model also suggests that future capabilities could be forecasted if one could estimate the frequency at which that skill would benefit prediction in the training corpus.
+
+Implications for mechanistic interpretability: If the Quantization Hypothesis is correct, then understanding a network reduces to enumerating its quanta. Having done this, the quanta could perhaps then be translated into a more interpretable format (something like code), studied in this format, and eventually executed in this format, rather than via the operation of the network.
+
+Outlook: Lastly, our decomposition of networks into quanta is reminiscent of Minsky’s Society of Mind [44] perspective that minds are decomposable into individually mindless “agents”. If this decomposition is indeed possible, then the quanta (agents) become natural objects of study within networks. This mesoscale understanding of networks, in terms of the internal modules which collectively constitute their performance, could perhaps act like statistical physics for deep learning, allowing us to bridge our microscale understanding of low-level training dynamics and our macroscale understanding of model performance.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Tamay Besiroglu, Neel Nanda, Tony Wang, David Bau, Ben Edelman, Brian Cheung, Wes Gurnee, Stephen Casper, Peter Hase, Davis Brown, Eleni Shor, Max Nadeau, and Xander Davies for helpful conversations and feedback. We thank Lauro Langosco for helping with code to visualize samples from The Pile. This work was supported by the Foundational Questions Institute, the Rothberg Family Fund for Cognitive Science, the NSF Graduate Research Fellowship (Grant No. 2141064), and IAIFI through NSF grant PHY-2019786.
+
+# References
+
+[1] Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory Diamos, Heewoo Jun, Hassan Kianinejad, Md Patwary, Mostofa Ali, Yang Yang, and Yanqi Zhou. “Deep learning scaling is predictable, empirically”. In: arXiv preprint arXiv:1712.00409 (2017).   
+[2] Jonathan S Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. “A constructive prediction of the generalization error across scales”. In: arXiv preprint arXiv:1909.12673 (2019).   
+[3] 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”. In: arXiv preprint arXiv:2001.08361 (2020).   
+[4] Tom Henighan, Jared Kaplan, Mor Katz, Mark Chen, Christopher Hesse, Jacob Jackson, Heewoo Jun, Tom B Brown, Prafulla Dhariwal, Scott Gray, et al. “Scaling laws for autoregressive generative modeling”. In: arXiv preprint arXiv:2010.14701 (2020).   
+[5] Mitchell A Gordon, Kevin Duh, and Jared Kaplan. “Data and parameter scaling laws for neural machine translation”. In: Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing. 2021, pp. 5915–5922.   
+[6] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. “Scaling vision transformers”. In: Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2022, pp. 12104–12113.   
+[7] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. “Training compute-optimal large language models”. In: arXiv preprint arXiv:2203.15556 (2022).   
+[8] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. “Emergent Abilities of Large Language Models”. In: Transactions on Machine Learning Research (2022). Survey Certification. ISSN: 2835-8856. URL: https://openreview.net/forum?id $\equiv$ yzkSU5zdwD.   
+[9] Jacob Steinhardt. Future ML Systems Will Be Qualitatively Different. Accessed: 2023-10-26. Jan. 2022. URL: https://bounded-regret.ghost.io/future-ml-systems-will-bequalitatively-different/.   
+[10] Deep Ganguli, Danny Hernandez, Liane Lovitt, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Nova Dassarma, Dawn Drain, Nelson Elhage, et al. “Predictability and surprise in large generative models”. In: 2022 ACM Conference on Fairness, Accountability, and Transparency. 2022, pp. 1747–1764.   
+[11] Chris Olah, Nick Cammarata, Ludwig Schubert, Gabriel Goh, Michael Petrov, and Shan Carter. “Zoom In: An Introduction to Circuits”. In: Distill (2020). https://distill.pub/2020/ circuits/zoom-in. DOI: 10.23915/distill.00024.001.   
+[12] Nick Cammarata, Gabriel Goh, Shan Carter, Ludwig Schubert, Michael Petrov, and Chris Olah. “Curve detectors”. In: Distill 5.6 (2020), e00024–003.   
+[13] Neel Nanda, Lawrence Chan, Tom Liberum, Jess Smith, and Jacob Steinhardt. “Progress measures for grokking via mechanistic interpretability”. In: arXiv preprint arXiv:2301.05217 (2023).   
+[14] Kenneth Li, Aspen K Hopkins, David Bau, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. “Emergent world representations: Exploring a sequence model trained on a synthetic task”. In: arXiv preprint arXiv:2210.13382 (2022).   
+[15] Kevin Wang, Alexandre Variengien, Arthur Conmy, Buck Shlegeris, and Jacob Steinhardt. “Interpretability in the Wild: a Circuit for Indirect Object Identification in GPT-2 small”. In: arXiv preprint arXiv:2211.00593 (2022).   
+[16] Nelson Elhage, Neel Nanda, Catherine Olsson, Tom Henighan, Nicholas Joseph, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Nova DasSarma, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodds, Danny Hernandez, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah. “A Mathematical Framework for Transformer Circuits”. In: Transformer Circuits Thread (2021). https://transformer-circuits.pub/2021/framework/index.html.   
+[17] Tom Lieberum, Matthew Rahtz, János Kramár, Geoffrey Irving, Rohin Shah, and Vladimir Mikulik. “Does circuit analysis interpretability scale? evidence from multiple choice capabilities in chinchilla”. In: arXiv preprint arXiv:2307.09458 (2023).   
+[18] Stephen Casper, Shlomi Hod, Daniel Filan, Cody Wild, Andrew Critch, and Stuart Russell. “Graphical clusterability and local specialization in deep neural networks”. In: ICLR 2022 Workshop on PAIR {\textasciicircum} 2Struct: Privacy, Accountability, Interpretability, Robustness, Reasoning on Structured Data. 2022.   
+[19] Trenton Bricken, Adly Templeton, Joshua Batson, Brian Chen, Adam Jermyn, Tom Conerly, Nick Turner, Cem Anil, Carson Denison, Amanda Askell, Robert Lasenby, Yifan Wu, Shauna Kravec, Nicholas Schiefer, Tim Maxwell, Nicholas Joseph, Zac Hatfield-Dodds, Alex Tamkin, Karina Nguyen, Brayden McLean, Josiah E Burke, Tristan Hume, Shan Carter, Tom Henighan, and Christopher Olah. “Towards Monosemanticity: Decomposing Language Models With Dictionary Learning”. In: Transformer Circuits Thread (2023). https://transformercircuits.pub/2023/monosemantic-features/index.html.   
+[20] Jonathan Frankle and Michael Carbin. “The lottery ticket hypothesis: Finding sparse, trainable neural networks”. In: arXiv preprint arXiv:1803.03635 (2018).   
+[21] Deniz Bayazit, Negar Foroutan, Zeming Chen, Gail Weiss, and Antoine Bosselut. “Discovering Knowledge-Critical Subnetworks in Pretrained Language Models”. In: arXiv preprint arXiv:2310.03084 (2023).   
+[22] Yixuan Li, Jason Yosinski, Jeff Clune, Hod Lipson, and John Hopcroft. Convergent Learning: Do different neural networks learn the same representations? arXiv:1511.07543 [cs]. Feb. 2016. URL: http://arxiv.org/abs/1511.07543 (visited on 08/19/2022).   
+[23] Thao Nguyen, Maithra Raghu, and Simon Kornblith. Do Wide and Deep Networks Learn the Same Things? Uncovering How Neural Network Representations Vary with Width and Depth. arXiv:2010.15327 [cs]. Apr. 2021. URL: http://arxiv.org/abs/2010.15327.   
+[24] Amil Dravid, Yossi Gandelsman, Alexei A. Efros, and Assaf Shocher. Rosetta Neurons: Mining the Common Units in a Model Zoo. arXiv:2306.09346 [cs]. June 2023. DOI: 10.48550/arXiv. 2306.09346. URL: http://arxiv.org/abs/2306.09346.   
+[25] Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah. “In-context Learning and Induction Heads”. In: Transformer Circuits Thread (2022). https://transformer-circuits.pub/2022/incontext-learning-and-induction-heads/index.html.   
+[26] Gwern Branwen. The scaling hypothesis. 2021. URL: https : / / gwern . net / scaling - hypothesis.   
+[27] Alethea Power, Yuri Burda, Harri Edwards, Igor Babuschkin, and Vedant Misra. “Grokking: Generalization beyond overfitting on small algorithmic datasets”. In: arXiv preprint arXiv:2201.02177 (2022).   
+[28] Boaz Barak, Benjamin L Edelman, Surbhi Goel, Sham Kakade, Eran Malach, and Cyril Zhang. “Hidden progress in deep learning: Sgd learns parities near the computational limit”. In: arXiv preprint arXiv:2207.08799 (2022).   
+[29] Stella Biderman, Hailey Schoelkopf, Quentin Anthony, Herbie Bradley, Kyle O’Brien, Eric Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, et al. “Pythia: A suite for analyzing large language models across training and scaling”. In: arXiv preprint arXiv:2304.01373 (2023).   
+[30] Leo Gao, Stella Biderman, Sid Black, Laurence Golding, Travis Hoppe, Charles Foster, Jason Phang, Horace He, Anish Thite, Noa Nabeshima, et al. “The pile: An 800gb dataset of diverse text for language modeling”. In: arXiv preprint arXiv:2101.00027 (2020).   
+[31] Utkarsh Sharma and Jared Kaplan. “Scaling Laws from the Data Manifold Dimension”. In: Journal of Machine Learning Research 23.9 (2022), pp. 1–34. URL: http://jmlr.org/ papers/v23/20-1111.html.   
+[32] Eric J. Michaud, Ziming Liu, and Max Tegmark. “Precision Machine Learning”. In: Entropy 25.1 (2023). ISSN: 1099-4300. DOI: 10.3390/e25010175. URL: https://www.mdpi.com/ 1099-4300/25/1/175.   
+[33] Yasaman Bahri, Ethan Dyer, Jared Kaplan, Jaehoon Lee, and Utkarsh Sharma. “Explaining neural scaling laws”. In: arXiv preprint arXiv:2102.06701 (2021).   
+[34] Alexander Maloney, Daniel A Roberts, and James Sully. “A Solvable Model of Neural Scaling Laws”. In: arXiv preprint arXiv:2210.16859 (2022).   
+[35] Blake Bordelon, Abdulkadir Canatar, and Cengiz Pehlevan. “Spectrum dependent learning curves in kernel regression and wide neural networks”. In: International Conference on Machine Learning. PMLR. 2020, pp. 1024–1034.   
+[36] Marcus Hutter. “Learning curve theory”. In: arXiv preprint arXiv:2102.04074 (2021).   
+[37] Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, et al. “Beyond the imitation game: Quantifying and extrapolating the capabilities of language models”. In: arXiv preprint arXiv:2206.04615 (2022).   
+[38] Rylan Schaeffer, Brando Miranda, and Sanmi Koyejo. “Are Emergent Abilities of Large Language Models a Mirage?” In: arXiv preprint arXiv:2304.15004 (2023).   
+[39] Sanjeev Arora and Anirudh Goyal. “A theory for emergence of complex skills in language models”. In: arXiv preprint arXiv:2307.15936 (2023).   
+[40] Lorenza Saitta, Attilio Giordana, and Antoine Cornuejols. Phase transitions in machine learning. Cambridge University Press, 2011.   
+[41] James B Simon, Maksis Knutins, Liu Ziyin, Daniel Geisz, Abraham J Fetterman, and Joshua Albrecht. “On the stepwise nature of self-supervised learning”. In: arXiv preprint arXiv:2303.15438 (2023).   
+[42] Mayee F Chen, Nicholas Roberts, Kush Bhatia, Jue Wang, Ce Zhang, Frederic Sala, and Christopher Ré. “Skill-it! A Data-Driven Skills Framework for Understanding and Training Language Models”. In: arXiv preprint arXiv:2307.14430 (2023).   
+[43] Stephanie Chan, Adam Santoro, Andrew Lampinen, Jane Wang, Aaditya Singh, Pierre Richemond, James McClelland, and Felix Hill. “Data distributional properties drive emergent in-context learning in transformers”. In: Advances in Neural Information Processing Systems 35 (2022), pp. 18878–18891.   
+[44] Marvin Minsky. Society of mind. Simon and Schuster, 1988.   
+[45] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. “Scikit-learn: Machine Learning in Python”. In: Journal of Machine Learning Research 12 (2011), pp. 2825–2830.   
+[46] Ronen Eldan and Yuanzhi Li. “TinyStories: How Small Can Language Models Be and Still Speak Coherent English?” In: arXiv preprint arXiv:2305.07759 (2023).   
+[47] Pablo Villalobos. Scaling Laws Literature Review. https://epochai.org/blog/scalinglaws-literature-review. Accessed: 2023-01-31. 2023.   
+[48] Jasha Droppo and Oguz Elibol. “Scaling laws for acoustic models”. In: arXiv preprint arXiv:2106.09488 (2021).   
+[49] Newsha Ardalani, Carole-Jean Wu, Zeliang Chen, Bhargav Bhushanam, and Adnan Aziz. “Understanding Scaling Laws for Recommendation Models”. In: arXiv preprint arXiv:2208.08489 (2022).
+
+# Appendix
+
+# A More general scaling laws
+
+If one learns the first $n$ quanta, reducing the loss from $b _ { k }$ to $a _ { k }$ ( $1 \leq k \leq n$ ), while the loss remains $b _ { k }$ for $k > n$ , the expected loss is given by:
+
+$$
+L _ { n } = \sum _ { k = 1 } ^ { n } a _ { k } p _ { k } + \sum _ { k = n + 1 } ^ { \infty } b _ { k } p _ { k } .
+$$
+
+In the main text, we used $a _ { k } = a$ and $b _ { k } = b$ for our model. However, one can imagine a variety of other choices for $a _ { k }$ and $b _ { k }$ .
+
+Case 1 $b _ { k } = - \mathrm { l o g } p _ { k }$ and $a _ { k } = 0$ , where $p _ { k } = k ^ { - ( \alpha + 1 ) } / \zeta ( \alpha + 1 )$ . This baseline for $b _ { k }$ is the error of a model which outputs the token frequencies, independent of the context (assuming that quanta involve the prediction of a particular token). The expected loss is given by:
+
+$$
+L _ { n } = \sum _ { k = 1 } ^ { n } 0 \cdot p _ { k } + \sum _ { k = n + 1 } ^ { \infty } \left( - \log p _ { k } \right) \cdot p _ { k } \approx { \frac { 1 + \alpha + \alpha \log \zeta ( \alpha + 1 ) } { \alpha ^ { 2 } \zeta ( \alpha + 1 ) } } n ^ { - \alpha } + { \frac { \alpha + 1 } { \alpha \zeta ( \alpha + 1 ) } } n ^ { - \alpha } \log n ,
+$$
+
+which contains a power law term $n ^ { - \alpha }$ plus a log term $n ^ { - \alpha } \log n$ . For very large $n$ , the log term can be ignored, so $L$ is still approximately a power law of $n$ with exponent $- \alpha$ , shown in Figure 6.
+
+![](images/672f97a9e564977bf19ec837a2d769d78a959909d99863f9a49882d66e704460.jpg)  
+Figure 6: Comparing different scaling laws. Setting $a _ { k } = 0$ , we compare $b _ { k } = - \mathrm { l o g } p _ { k }$ (solid lines) and $b _ { k } = 1$ (dashed lines) for different alphas. Although the $b _ { k } = - \mathrm { l o g } \ p _ { k }$ case would cause an extra loss term $n ^ { - \alpha } \mathrm { l o g } n$ in additional to the power law term $n ^ { - \alpha }$ , the loss becomes a power law asymptotically when $n$ becomes large.
+
+Case 2 $b _ { k } = - \mathrm { l o g } p _ { k }$ and $a _ { k } = - \mathrm { l o g } \left( C p _ { k } \right) \left( C > 1 \right)$ , where $p _ { k } = k ^ { - ( \alpha + 1 ) } / \zeta ( \alpha + 1 )$ . The expected loss is given by:
+
+$$
+\therefore = \sum _ { k = 1 } ^ { n } ( - \log { ( C p _ { k } ) } ) \cdot p _ { k } + \sum _ { k = n + 1 } ^ { \infty } ( - \log { p _ { k } } ) \cdot p _ { k } \approx \frac { \log { C } } { \alpha \zeta ( \alpha + 1 ) } n ^ { - \alpha } - \log { C } + \frac { 1 + \alpha + \alpha \log { \zeta ( \alpha + 1 ) } } { \alpha ^ { 2 } \zeta ( \alpha + 1 ) } ,
+$$
+
+which is a power law $n ^ { - \alpha }$ plus a constant.
+
+# B Additional results on multitask sparse parity
+
+Training dynamics: When loss is broken down by subtask on multitask sparse parity, learning curves consist of many reverse-S shaped curves, and mean loss decreases smoothly as an average over these curves. In Figure 7, we show loss versus time for each subtask for training runs in both the single-epoch and multi-epoch regimes. In Figure 8 we show how convergence time for each subtask relates to the frequency of that subtask.
+
+![](images/16185066cfc05c8cba5d8ec69ee5843e5437d228d0061a5622ede57fd27c0de2.jpg)  
+Figure 7: Training dynamics on the multitask sparse parity dataset consist of many “phase transitions” when decomposed by subtask – the loss curve for each subtask drops following an initial plateau of no apparent progress, in line with [28]. The mean loss decreases smoothly, averaging over these phase transitions in the model’s performance on subtasks. We show curves for single-epoch training (top) and multi-epoch training on 5 million samples (bottom). The dashed red line indicates the early stopping point where mean test loss is minimized. For these runs, $\alpha = 0 . 4$ .
+
+![](images/4067a20c8211bba348c53d86f9026e00244918c5a8f99a5153d0c1784f59738f.jpg)  
+Figure 8: Convergence time for each subtask versus the frequency of that subtask. We see that convergence time $S _ { k }$ on subtask $k$ is $S _ { k } \propto p _ { k } ^ { - 0 . 8 1 }$ rather than $\bar { S } _ { k } \propto p _ { k } ^ { - 1 }$ as we had expected. This leads to a steeper scaling w.r.t. $S$ than expected from theory. For these experiments, we used $\alpha = 0 . 4$ , and so we would have predicted $\alpha _ { S } \approx 0 . 2 9$ but instead we get $\alpha _ { S } \approx 0 . 4 5$ . We consider the model to have converged on a subtask once it gets mean test loss less than 0.1 bits on that subtask.
+
+Scaling for varying $\alpha$ : In Figure 10 we show scaling curves on multitask sparse parity in $N , S , D$ for a variety of quanta distribution parameters $\alpha$ . While all scaling curves appear to be power laws, the relationship between $\alpha _ { N } , \alpha _ { S } , \alpha _ { D }$ and $\alpha$ is not precisely as predicted by theory:
+
+1. Parameter scaling: We observe that the relationship between $\alpha _ { N }$ and $\alpha$ deviates a bit from the prediction $\alpha _ { N } = \alpha$ , with $\alpha _ { N } < \alpha$ for small $\alpha$ and $\alpha _ { N } > \alpha$ for large $\alpha$ . Perhaps model size does not influence learning just by changing capacity, but also by affecting optimization.
+
+![](images/f19028b481fd91efb78f9dedff39d425eb1325005e7cc2a9ce2d079a06fbe09b.jpg)  
+Figure 9: Number of subtasks learned $( n )$ , including subtasks learned after early-stopping would have terminated the training run, versus training samples $D$ for a variety of $\alpha$ . We see that the relation $n \propto D ^ { 1 / ( \alpha + 1 ) }$ approximately holds, in line with theory. Deviation from theory for the scaling exponent of loss $L$ w.r.t. $D$ therefore likely originates from our failure to regularize network training, leading to early-stopping ending training before some subtasks can be learned.
+
+2. Step scaling: We observe that $\alpha _ { S }$ is consistently higher than the theoretical prediction $\alpha / ( \alpha + 1 )$ . In Figure 8, we saw that the number of steps to convergence for each subtask did not precisely follow $S _ { k } \propto p _ { k } ^ { - 1 }$ , but was closer to $S _ { k } \propto p _ { k } ^ { - 0 . 8 1 }$ −0.81. This means that many subtasks converge faster than we would expect, producing a steeper scaling curve.
+
+3. Data scalaing: We observe that $\alpha _ { D }$ is substantially higher than the theoretical prediction $\alpha / ( \alpha + 1 )$ for small $\alpha$ . We think this may be related to the fact that early-stopping cuts off training before all subtasks are learned as observed in Figure 7. In Figure 9, we show how the number of subtasks learned $n$ , when we include subtasks learned after early-stopping, seems to be in line with theory: $n \propto D ^ { 1 / ( \alpha + 1 ) }$ .
+
+Better understanding the precise nature of power law scaling on multitask sparse parity is an interesting avenue for future work.
+
+![](images/9bdaa503b5e1f78acba48c145bccfd77374586823f596c4b7901b872a5741c71.jpg)  
+Figure 10: Scaling in parameters $( N )$ , single-epoch training time $( S )$ , and multi-epoch training samples $( D )$ for varying quanta power law distribution parameter $\alpha$ on multitask sparse parity. We notice that scaling curves in steps $S$ are typically steeper than the $\alpha _ { S } = \alpha / ( \alpha + 1 \bar { ) }$ predicted from theory, and that for low $\alpha$ the scaling curves in $D$ also deviate from theory substantially.
+
+# C Additional results on language models
+
+In Figure 11 we show how the distribution over losses changes across time during a training run, rather than across model scales like in Figure 3.
+
+In Figure 13 we show additional examples from clusters discovered with QDG.
+
+![](images/ea4e3c8f34c7e1593855d73664f455412fd7aa1a4b10f370bcbf34db1f063891.jpg)  
+Figure 11: Left: Training curves (scaling w.r.t. steps $S$ ) of mean test loss for Pythia models. We measure exponents $\alpha _ { S }$ between 0.037 and 0.06. Center: the distribution $p ( L )$ over time. Over time, models achieve $\approx 0$ loss on an increasing fraction of tokens, similar to scaling in model size. Right: The distribution $L \cdot p ( L )$ over time.
+
+# C.1 Details of application of QDG to LLMs
+
+When applying QDG to language models, we use gradients within self-attention and MLP layers, but do not include embed, unembed, or layer norm gradients when we flatten and concatenate gradients into a vector $g$ .4 We choose samples $( x _ { i } , y _ { i } )$ for which our $1 9 \mathrm { m }$ -parameter model achieves a crossentropy loss less than 0.1 nats. We filter based on this criteria since (1) we cannot cluster samples based on model mechanism if the model does not have such a mechanism for performing prediction correctly on those samples and (2) our intuition that samples with particularly low loss are more likely to be monogenic. We further exclude samples which can be solved via induction on the context5, since such samples are quite common (possibly interfering with our task of finding diverse quanta) and since early experiments indicated that QDG had trouble clustering such samples together. We choose 10000 such samples to perform clustering on from the test set of The Pile. After computing the affinity matrix $\hat { C }$ , we use the spectral clustering implementation from scikit-learn [45] with labels assigned via k-means.
+
+# D Quanta discovery on TinyStories
+
+We also apply QDG to TinyStories-33M, a language model trained on the TinyStories dataset [46]. We consider only tokens on which TinyStories-33M achieves a loss less than 1 bit of cross-entropy. We apply QDG to 10000 such samples, clustering their gradients with spectral clustering with n_clusters $= ~ 4 0 0$ . We show some samples from the resulting clusters in Figure 14. Many of these clusters reflect some simple recurring pattern in the TinyStories dataset, like predicting “ time” after “Once upon a”, which many documents in the dataset start with. Some other clusters are more interesting however, like Cluster 11, which seems to involve predicting the correct noun in a sentence where that noun was referred to earlier in the sentence or in previous sentences.
+
+![](images/6af8cfa78c1793b974d61687c9d1aaaa540d7c790c7f38cb02c6473800941d1c.jpg)  
+Figure 12: Additional LLM scaling curves on individual samples which exhibit sharp vs smooth improvement. If the Quantization Hypothesis is true for language modeling, then we would interpret samples with sharp drops as “monogenic” and samples with gradual progress as “polygenic”.
+
+# E The difficulty of estimating the power law exponent from clusters
+
+In Section 5.1, when we looked at the distribution over elements in each cluster, we did not perfectly recover a Zipf distribution with exponent $\approx 1 . 0 8$ that we expected from our theory. In this section, we describe the difficulty of accurately estimating such an exponent with our method.
+
+# E.1 QDG on multitask sparse parity
+
+As a first experiment, we performed QDG on multitask sparse parity, where there is a known, artificially-imposed power law distribution over subtasks. We train a width-500 single-hidden-layer ReLU MLP on multitask sparse parity with $\alpha = 0 . 4$ and with $n = 1 0 0$ , $k = 3$ , and $n _ { \mathrm { t a s k s } } = 5 0 0$ We then took 10000 samples which the network achieves $\approx 0$ loss on (sampled from the Zipf distribution over subtasks with exponent 1.4). We compute gradients of cross-entropy loss w.r.t. all model parameters for these samples, and then perform QDG just like for LLMs. We show results in Figure 15. We plot the full similarity matrix where samples are ordered according to their a priori known subtask, rather than their cluster from QDG, and see a clear pattern where elements from the same subtask have on average higher angular similarity than elements between subtasks. However, from the rank-frequency plot of the clusters, we do not recover a slope of -1.4, but rather a lower slope of $\approx - 1 . 1$ . This shows that even when there is an exact decomposition of inputs into subtasks with a known Zipf distribution over these subtasks, that we do not perfectly recover this Zipf distribution from QDG.
+
+![](images/a903e28151db5eebd912cc5fc46cd2b9a2ed948bb6a4600757ab047f1b9de0d3.jpg)  
+Figure 13: Additional examples of clusters of inputs discovered by QDG. Like in Figure 1, we used 10000 samples and n_clusters of 400.
+
+# E.2 A toy model of QDG uncertainty and bias
+
+A toy model: To understand the bias of spectral clustering, we develop the following toy model. We assume the dataset has $N = 1 0 0 0$ subtasks, each subtask containing $\begin{array} { r } { \dot { n } _ { i } = \lfloor \frac { A } { i ^ { \alpha } } \rfloor ( 1 \leq i \dot { \leq } N ) } \end{array}$ tokens $\textstyle \mathcal { A } = 1 0 0 0 )$ . We use a Gaussian distribution $\mathcal { N } ( \mathbf { m } _ { i } , \sigma ^ { 2 } \mathbf { I } _ { d \times d } )$ to model gradients within a subtask $i$ where $d$ is the embedding dimension, $\sigma$ is the noise level, and $\mathbf { m } _ { i }$ is the Gaussian mean. $\mathbf { m } _ { i }$ itself is drawn from the standard Gaussian distribution $\mathbf { m } _ { i } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } _ { d \times d } )$ . We define the similarity between two vectors $\mathbf x , \mathbf y$ to be $\begin{array} { r } { \sin \equiv 1 + \frac { \mathbf x } { | \mathbf x | } \cdot \frac { \mathbf y } { | \mathbf y | } } \end{array}$ . We compute pairwise similarity between all $\textstyle \sum _ { i = 1 } ^ { N } n _ { i }$ tokens, and input the similarity matrix to the spectral clustering algorithm. We also need to specify the number of clusters $k$ .
+
+We have two hyperparameters in the toy model, the embedding dimension $d$ and the noise level $\sigma$ We need to determine them such that this toy model can decently imitate LLM results (Figure 5). We fix $\alpha = 1$ , sweeping $d = \{ 3 0 , 1 0 0 , 1 0 0 0 \}$ , $\sigma = \{ 0 , 0 . 5 , 2 . 0 \}$ , and $k = \{ 1 0 0 , 2 0 0 , 5 0 0 \}$ . As shown in Figure 16, the high-dimension $d = 1 0 0 0 ^ { \circ } ,$ ) large-noise $\sigma = 2 . 0$ ) scheme seem to best agree with the LLM results, since the $k = 2 0 0$ curve can reproduce the sag and the cliff present in LLM curves.
+
+Estimating $\alpha$ from the frequency curve is hard, in fact, the slope depends on $k$ and the region used to estimate it. However, we observe that different $k$ curves form a clear envelope, whose slope is robust in a reasonably wide region. The envelope slope seems to indicate $\alpha$ . We fix $d = 1 0 0 0$ and $\sigma = 2 . 0$ , sweeping $\alpha = \{ 0 . 8 , 0 . 9 , 1 . 0 , 1 . 1 , 1 . 2 , 1 . 3 , 1 . 4 , 1 . 5 \}$ . For each $\alpha$ , we estimate the slope of the envelope. Although there is clear correlation between the estimated envelope and $\alpha$ , if we use the envelope slope to estimate $\alpha$ , the error is on the order of 0.2, as shown in Figure 17.
+
+![](images/53290fa5f765ffe08427e3d8cbecf91656feb1fbea90d37bc6c3cb184011d37c.jpg)  
+Figure 14: Examples of clusters within the TinyStories dataset, discovered by QDG on the TinyStories-33M model. Here we just show samples from four out of $4 0 0 \mathtt { n }$ _clusters
+
+![](images/8fde60922ccb18ae7f75745f43cbc935a089aaef746d1ba23c38f9ae84c5ca33.jpg)  
+Figure 15: Similarity matrix and rank-frequency plots from QDG on multitask sparse parity. Despite sparse parity having a known decomposition into subtasks which are power law distributed in frequency, we do not recover this same power law from samples. We used $\alpha = 0 . 4$ for the frequency distribution for an expected rank-frequency power law exponent of -1.4, but measure a rank-frequency envelope slope closer to -1.1.
+
+# F Parameter and data scaling exponents across studies
+
+In Figure 18, we show $\alpha _ { N }$ and $\alpha _ { D }$ (or possibly $\alpha _ { S }$ , depending on the study) for a variety of prior studies of deep learning scaling, as compiled by Villalobos [47]. While the data is messy, it is intriguing that most of the Rosenfeld et al. [2] samples lie below the $\alpha _ { D } = \alpha _ { N }$ line, as our model would predict. The scaling exponents from Hoffmann et al. [7] are slightly closer to our prediction than the relation $\alpha _ { D } = \alpha _ { N }$ , which has been proposed by other models of neural scaling laws. Overall though, the existing empirical results are too messy to definitively support or contradict our model.
+
+# G Estimates of compute used for our experiments
+
+Multitask sparse parity: Our training script takes roughly 1-4 hours (depending on network size) to perform a single-epoch training run on a GPU. When training multi-epoch on a fixed dataset, runs take typically between 3-10 minutes, with some outliers taking much longer. Our largest experiment was for Figure 10, where we trained networks of varying width on data with varying distributions over subtasks (with different power law exponents). 467 runs completed with a total running time of approximately 1450 hours. These experiments were run on a cluster with heterogeneous hardware. Availble GPUs include NVIDIA A100, RTXA6000, QUADRORTX6000, GEFORCERTX2080TI, GEFORCERTX2080, GEFORCEGTX1080TI, titan-x, and tesla-v100.
+
+Pythia model scaling evaluations: We evaluated Pythia models on NVIDIA A100 80GBs. We do not have available the running time used when computing loss on approximately ten million tokens (for which we reported scaling statistics on), although it was likely less than an hour per model. The most expensive experiments were for Figure 11, where we evaluated the first four models in the Pythia suite across 143 checkpoints for a total of 572 evaluations. We likely used some hundreds of A100-hours for this, though possibly less than 100 hours.
+
+QDG: We ran our QDG experiments on an NVIDIA A100 80GB. For the smallest Pythia model and for 10000 samples, it takes a few hours to compute the similarity matrix. We performed this computation only a handful of times.
+
+![](images/718b99d9415e349831255b9ae7205570a0c7798515de256da2273d3af559c0d9.jpg)  
+Figure 16: To understand the bias of spectral clustering, we apply spectral clustering to a toy model with different embedding dimension $d$ , noise scale $\sigma$ and number of cluster $k$ . The high-dimension $d = 1 0 0 0$ ) large-noise $\sigma = 2 . 0$ ) scheme seems to best agree with the LLM results (Figure 5).
+
+![](images/7cf5642761530d7985b298fbc73952739d52254bfdd5aa62aad746ab37a10512.jpg)  
+Figure 17: The difficulty of measuring $\alpha$ from curves. We apply spectral clustering to a toy model with different $\alpha$ and number of clusters $k$ . For a fixed $\alpha$ , different $k$ curves define an envelope. One could use the envelope slope to infer $\alpha$ , but this incurs errors around 0.2.
+
+![](images/e4386abc158f75a6cd5486513ae6b422dab683ba89d6ae5ee46becede9b73c9d.jpg)  
+Figure 18: Parameter and data scaling exponents from various studies of deep learning scaling, compiled from the database of neural scaling laws from [47]. Our model of scaling predicts that $\alpha _ { D } \bar { = } \alpha _ { N } / ( \alpha _ { N } + 1 )$ , indicated with the solid black line. Visible points are from [2, 3, 7, 5, 48]. [49] is above the visible window of the figure.

parse/dev/G5RwHpBUv0/G5RwHpBUv0.md

@@ -0,0 +1,211 @@
+# Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation
+
+Yuval Kirstainτ Adam Polyakτ Uriel Singer
+
+Shahbuland Matianaσ Joe Pennaσ Omer Levyτ
+
+τ Tel Aviv University σ Stability AI yuval.kirstain@cs.tau.ac.il
+
+# Abstract
+
+The ability to collect a large dataset of human preferences from text-to-image users is usually limited to companies, making such datasets inaccessible to the public. To address this issue, we create a web app that enables text-to-image users to generate images and specify their preferences. Using this web app we build Pick-a-Pic, a large, open dataset of text-to-image prompts and real users’ preferences over generated images. We leverage this dataset to train a CLIP-based scoring function, PickScore, which exhibits superhuman performance on the task of predicting human preferences. Then, we test PickScore’s ability to perform model evaluation and observe that it correlates better with human rankings than other automatic evaluation metrics. Therefore, we recommend using PickScore for evaluating future text-to-image generation models, and using Pick-a-Pic prompts as a more relevant dataset than MS-COCO. Finally, we demonstrate how PickScore can enhance existing text-to-image models via ranking.1
+
+![](images/564557e489507874f20b9dc4441e985237ef1c196efa6e1538412840ae5e4a7a.jpg)  
+Figure 1: Images generated via our web application, showing darkened non-preferred images (left) and preferred images (right).
+
+# 1 Introduction
+
+Recent advances in aligning language models with user behaviors and expectations have placed a significant emphasis on the ability to model user preferences [10, 1, 3]. However, little attention has been paid to this ability in the realm of text-to-image generation. This lack of attention can largely be attributed to the absence of a large and open dataset of human preferences over state-of-the-art image generation models.
+
+To fill this void, we create a web application that enables users to generate images using state-of-theart text-to-image models while specifying their preferences. With explicit consent from the users, we collect their prompts and preferences to create Pick-a-Pic, a publicly available dataset comprising over half-a-million examples of human preferences over model-generated images.2 Each example in our dataset includes a prompt, two generated images, and a label indicating the preferred image, or a tie when no image is significantly preferred over the other. Notably, Pick-a-Pic was created by real users with a genuine interest in generating images. This interest differs from that of crowd workers who lack the intrinsic motivation to produce creative prompts or the original intent of the prompt’s author to judge which image better aligns with their needs.
+
+Tapping into authentic user preferences allows us to train a scoring function that estimates the user’s satisfaction from a particular generated image given a prompt. To train such a scoring function we finetune CLIP-H [12, 7] using human preference data and an analogous objective to that of InstructGPT’s reward model [10]. This objective aims to maximize the probability of a preferred image being picked over an unpreferred one, or even the probability in cases of a tie. We find that the resulting scoring function, PickScore3, achieves superhuman performance in the task of predicting user preferences (a $70 . 5 \%$ accuracy rate, compared to humans’ $6 8 . 0 \%$ ), while zero-shot CLIP-H $( 6 0 . 8 \% )$ and the popular aesthetics predictor [14] $( 5 6 . 8 \% )$ perform closer to chance $( 5 6 . 8 \% )$ .
+
+Equipped with a dataset for human preferences and a state-of-the-art scoring function, we propose updating the standard protocol for evaluating text-to-image generation models. First, we suggest that researchers evaluate their text-to-image models using prompts from Pick-a-Pic, which better represent what humans want to generate than mundane captions, such as those found in MS-COCO [2, 9]. Second, to compare PickScore with FID, we conduct a human evaluation study and find that even when evaluated against MS-COCO captions, PickScore exhibits a strong correlation with human preferences (0.917), while ranking with FID yields a negative correlation (-0.900). Importantly, we also compare PickScore with other evaluation metrics using model rankings inferred from real user preferences. We observe that PickScore is more strongly correlated with ground truth rankings, as determined by real users, than other evaluation metrics. Thus, we recommend using PickScore as a more reliable evaluation metric than existing ones.
+
+Finally, we explore how PickScore can improve the quality of vanilla text-to-image models via ranking. To accomplish this, we generate images with different initial random noises as well as different templates (e.g. “breathtaking [prompt]. award-winning, professional, highly detailed”) to slightly alter the user prompt. We then test the impact of selecting the top image according to different scoring functions. Our findings indicate that human raters prefer images selected by PickScore more than those selected by CLIP-H [7] (win rate of $7 1 . 3 \%$ ), an aesthetics predictor [14] (win rate of $8 5 . 1 \%$ , and the vanilla text-to-image model (win rate of $7 1 . 4 \%$ ).
+
+In summary, the presented work addresses a gap in the field of text-to-image generation by creating a large, open, high-quality dataset of human preferences over user-prompted model-generated images. We demonstrate the potential of this dataset by training a scoring function, PickScore, which exhibits a performance superior to any other publicly-available automatic scoring function, in predicting human preferences, evaluating text-to-image models, and improving them via ranking. We encourage the research community to adopt Pick-a-Pic and PickScore as a basis for further advances in text-to-image modeling and incorporating human preferences into the learning process.
+
+![](images/4f1c8249c412f1f948bb2399461429fe94f8eeb6587a76471d1f73fef2cc8abb.jpg)  
+Figure 2: How Pick-a-Pic data is collected through the app: (a) the user first writes a caption, and receives two images; (b) the user makes a preference judgment; (c) a new image is presented instead of the rejected image. This flow repeats itself until the user changes the prompt.
+
+# 2 Pick-a-Pic Dataset
+
+The Pick-a-Pic dataset4 was created by logging user interactions with the Pick-a-Pic web application for text-to-image generation. Overall, the Pick-a-Pic dataset contains over 500,000 examples and 35,000 distinct prompts. Each example contains a prompt, two generated images, and a label for which image is preferred, or if there is a tie when no image is significantly preferred over the other. The images in the dataset were generated by employing multiple backbone models, namely, Stable Diffusion 2.1, Dreamlike Photoreal $2 . 0 ^ { 5 }$ , and Stable Diffusion XL variants [13] while sampling different classifier-free guidance scale values [6]. As we continue with our efforts to collect more user interactions through the Pick-a-Pic web app and decrease the number of NSFW examples included in the dataset, we will periodically upload new revisions of the dataset.
+
+The Pick-a-Pic Web App To ensure maximum accessibility for a wide range of users, the user interface was designed with simplicity in mind. The application allows users to write creative prompts and generate images. At each turn, the user is presented with two generated images (conditioned on their prompt), and asked to select their preferred option or indicate a tie if they have no strong preference. Upon selection, the rejected (non-preferred) image is replaced with a newly generated image, and the process repeats. The user can also clear or edit the prompt at any time, and the app will generate new images appropriately. Figure 2 illustrates the usage flow.
+
+Real Data from Real Users A key advantage of Pick-a-Pic is that our data is collected from real, intrinsically-motivated users, rather than paid crowd workers. We achieve this by approaching a wide audience through various social media channels such as Twitter, Facebook, Discord, and Reddit. At the same time, we mitigate the risk of collecting low-quality data resulting from potential misuse of the application by implementing several quality control measures. First, users are required to authenticate their identity using either a Gmail or a Discord account.6 Second, we closely monitor user activity logs and take action to ban users who generate NSFW content, use multiple instances of the web app simultaneously, or make judgments at an unreasonably fast pace. Third, we use a list of NSFW phrases to prevent users from generating harmful content. Last, we limit users to 1000 interactions and periodically increase the limit. These measures work in tandem to ensure the integrity and reliability of Pick-a-Pic’s data.
+
+Annotation Methodology While piloting the web app, we experimented with different annotation strategies to optimize for data quality, efficiency of collection, and user experience. Specifically, we tested the following annotation options: (1) 4 images, no ties; (2) 2 images, no ties; (3) 2 images,
+
+![](images/6615d8f4afc55088183eb137afcc1688419bf3bcc1608706d11628e7e775d08b.jpg)
+
+![](images/ea1558bc4e7d938d5ae4ce2f4af5efd3fc4bc1d71a13c07ffcd04d4b8da208ec.jpg)  
+Figure 3: The Pick-a-Pic dataset enables us to perform model selection (a), and model evaluation (b).
+
+(a) Win rate versus classifier-free guidance scale for Stable Diffusion XL (Alpha).
+
+(b) Preference distribution when comparing Stable Diffusion 2.1 with Dreamlike Photoreal 2.0.
+
+with ties. We found that the latter option (2 images, with ties) exceeds the other two in terms of user engagement and inter-rater agreement.
+
+Preprocessing When processing the collected interactions, we filter prompts with NSFW phrases and banned users. We acknowledge that there are still NSFW images and prompts, and will periodically attempt to update the dataset and reduce such occurrences. To divide the dataset into training, validation, and testing subsets, we first sample one thousand prompts, ensuring that each prompt was created by a unique user. Next, we randomly divide those prompts into two sets of equal size to create the validation and test sets. We then sample exactly one example for each prompt to include in these sets. For the training set, we include all examples that do not share a prompt with the validation and test sets. This approach ensures that no split shares prompts with another split, and the validation and test sets do not suffer from being non-proportionally fitted to a specific prompt or user.
+
+Statistics Since the creation of the Pick-a-Pic web app we have gathered 968,965 rankings which originated from 66,798 prompts and 6,394 users. However, as the Pick-a-Pic dataset is constantly updating, the reported experiments in this paper involve an NSFW filtered and not fully updated version of Pick-a-Pic, that contains 583,747 training examples, and 500 validation and test examples. The training set of this dataset contains 37,523 prompts from 4,375 distinct users.
+
+Model Selection and Evaluation The Pick-a-Pic dataset offers a unique opportunity for a model selection and evaluation methodology, leveraging users’ preferences for unbiased analysis. To illustrate this opportunity, we use the collected data and analyze the impact of changing the classifierfree guidance scale of Stable Diffusion XL (Alpha variant) on its performance. Specifically, we compare human preferences made when both images were generated by Stable Diffusion XL (Alpha variant) but using different classifier-free guidance scales7. For each scale, we compute the win ratio, representing the percentage of judgments where its use led to a preferred image. We also calculate the corresponding tie and lose ratios for each scale, enabling a detailed analysis of which classifier-free guidance scales are more effective. Our results are depicted in Figure 3 (a), and verify for example, that a guidance scale of 9 usually yields preferred images when compared to a guidance scale of 3.
+
+Furthermore, by examining user preferences between images generated by different backbone models, we can determine which model is preferred more by users. For instance, considering judgments in which one image was generated by Dreamlike Photoreal 2.0 and the other by Stable Diffusion 2.1, we can evaluate which model is more performant. As shown in fig. 3 (b), users usually prefer Dreamlike Photoreal 2.0 over Stable Diffusion 2.1. We encourage researchers to contact us and include their text-to-image models in the Pick-a-Pic web app for the purpose of model selection and evaluation.
+
+# 3 PickScore
+
+One valuable outcome from collecting a large, natural dataset of user preferences is that we can use it to train a function that scores the quality of a generated image given a prompt. We train the PickScore scoring function over Pick-a-Pic by combining a CLIP-style model with a variant of
+
+InstructGPT’s reward model objective [10]. PickScore is able to predict user preferences in held-out Pick-a-Pic prompts better than any other publicly-available scoring function, surpassing even expert human annotators (Section 4). Such a scoring function can be of value for various scenarios, such as performing model evaluation (Section 5), increasing the quality of generated images via ranking (Section 6), building better large-scale datasets to improve text-to-image models [14], and improving text-to-image models through weak supervision (e.g. RLHF).
+
+Model PickScore follows the architecture of CLIP [12]; given a prompt $x$ and an image $y$ , our scoring function $s$ computes a real number by representing $x$ using a transformer text encoder and $y$ using a transformer image encoder as $d$ -dimensional vectors, and returning their inner product:
+
+$$
+s ( x , y ) = E _ { \mathrm { t x t } } ( x ) \cdot E _ { \mathrm { i m g } } ( y ) \cdot T
+$$
+
+Where $T$ is the learned scalar temperature parameter of CLIP.
+
+Objective The input for our objective includes a scoring function $s$ , a prompt $x$ , two images $y _ { 1 } , y _ { 2 }$ , and a preference distribution vector $p$ , which captures the user’s preference over the two images. Specifically, $p$ takes a value of $[ 1 , 0 ]$ if $y _ { 1 }$ is preferred, $[ 0 , 1 ]$ if $y _ { 2 }$ is preferred, or [0.5, 0.5] for ties. Given this input, the objective optimizes the scoring function’s parameters by minimizing the KL-divergence between the preference $p$ and the softmax-normalized scores of $y _ { 1 }$ and $y _ { 2 }$ :
+
+$$
+\hat { p } _ { i } = \frac { \exp s ( x , y _ { i } ) } { \sum _ { j = 1 } ^ { 2 } \exp s ( x , y _ { j } ) }
+$$
+
+$$
+{ L _ { \mathrm { p r e f } } = \sum _ { i = 1 } ^ { 2 } p _ { i } \left( \log p _ { i } - \log \hat { p } _ { i } \right) }
+$$
+
+Since many examples can originate from the same prompt, we mitigate the risk of overfitting to a small set of prompts by applying a weighted average when reducing the loss across examples in the batch. Specifically, we weigh each example in the batch, with an inverse proportion to its prompt frequency in the dataset. This objective is analogous to InstructGPT’s reward model objective [10]. We also experiment with incorporating in-batch negatives into the objective, but find that this yields a less accurate scoring function (see Appendix).
+
+Training We finetune CLIP-H [7] using our framework8 on the Pick-a-Pic training set. We train the model for 4,000 steps, with a learning rate of 3e-6, a total batch size of 128, and a warmup period of 500 steps, which follows a linearly decaying learning rate; the experiment is completed in less than an hour with 8 A100 GPUs. We did not perform hyperparameter search, which might further improve results. For model selection, we evaluate the model’s accuracy on the validation set (without the option for a tie) in intervals of 100 steps, and keep the best-performing checkpoint.
+
+# 4 Preference Prediction
+
+We first evaluate PickScore on the task it was trained to do: predict human preferences. We find that PickScore outperforms all other baselines, including expert human annotators.
+
+Metric To evaluate the ability of models to predict human preferences, we use an adapted accuracy metric that accounts for the possibility of a tie. Our metric assigns one point to the model for predicting the same label as the user, half a point if either label or prediction is a tie (but not both), and zero otherwise.
+
+Tie Threshold Selection Utilizing the notation specified in Section 3, each model requires a tie threshold probability $t$ to predict a tied outcome when $| \hat { p } _ { 1 } - \hat { p } _ { 2 } | < t$ . To achieve this, we evaluate each model on the validation set using various tie threshold probabilities and subsequently determine the most optimal tie threshold for each model. For human experts, we do not perform tie selection and explicitly allow them to select a tie.
+
+![](images/9f2a5b680227fc5555664385601d9d911f6c233975c5110318349257d8bc1246.jpg)  
+Figure 4: Disagreement between CLIP-H (left) and PickScore (right) on the Pick-a-Pic validation set. We add green borders around images that humans preferred.   
+Table 1: Quantitative results on Pick-a-Pic.   
+(a) Accuracy across different tie thresholds on the Pick-a-Pic validation set
+
+![](images/e474fbe1c1382557c67a3e7a78313cb58d48d0b60f497c689608db2e1fdf5502.jpg)
+
+<table><tr><td>Model</td><td>Accuracy</td></tr><tr><td>Random Human Expert</td><td>56.8 68.0</td></tr><tr><td>Aesthetics [14]</td><td>56.8</td></tr><tr><td>CLIP-H[7]</td><td>60.8</td></tr><tr><td>ImageReward [18]</td><td>61.1</td></tr><tr><td>HPS [17]</td><td>66.7</td></tr><tr><td>PickScore (Ours)</td><td>70.5</td></tr></table>
+
+(b) Performance on the Pick-a-Pic test set.
+
+Baselines We compare our model with CLIP-H [7], an aesthetics predictor [14] built on top of CLIP-L [12], a random classifier, and human experts.9 For completeness, we also compare our results with models from concurrent work, namely, HPS [17] and ImageReward [18].
+
+Results First, we compare the models’ performance on the validation set across different tie thresholds. Figure 1a shows that PickScore outperforms the baselines across almost all thresholds, and achieves the highest global score by a wide margin. After selecting the best-performing tie threshold for each model, we use the threshold to evaluate the different models on the test set.
+
+Table 1b shows that the aesthetics score (56.8) and CLIP-H (60.8) perform closer to a random chance baseline (56.8), while PickScore $( 7 0 . 5 \pm 0 . 1 4 2 ) ^ { 1 0 }$ achieves superhuman performance, as it even outperforms human experts (68.0). It is important to emphasize a core difference between real users that produce the ground truth labels and annotators used to evaluate human performance. The users that produce the ground truth are actual text-to-image users, which have an idea (which may be incomplete) for an image, and invent a prompt (which may lack details) with hope that the resulting image will match their preferences. In contrast, annotators that are used to measure human performance are oblivious to the original user’s context, idea, and motivation. Therefore, superhuman performance on this task means that the model is able to outperform a human annotator that is oblivious to the original user’s context, idea, and motivation. The superhuman performance of PickScore showcases the importance of using real users as ground truth rather than expert annotators when collecting human preferences. Moreover, the relatively modest human performance (68.0) on the task, when compared to a random baseline (56.8), shows that predicting human preferences in text-to-image generation is a difficult task for human annotators.
+
+For completeness, we also include the results of concurrent work from HPS [17], which scores 66.7, and ImageReward [18], which scores 61.1; PickScore outperforms both. To further illustrate the differences between CLIP-H and PickScore, we showcase examples of disagreement from the Pick-a-Pic validation set in Figure 4. We notice that PickScore often chooses more aesthetically pleasing images than CLIP-H; at times, at the cost of faithfulness to the prompt.
+
+![](images/99cadb8ca71029811819199799e68e1edea3c264eebdc59f89766d61f322760b.jpg)  
+Figure 5: Images generated using the same seed and model, but using different classifier-free guidance (CFG) scales. Even though high guidance scales lead to worse FID, humans usually find them more pleasing than low guidance scales.
+
+![](images/9bb28f42655114880fc91f20aa4cbafa0524ce03842af7ee4cfe0777b4d278be.jpg)  
+Figure 6: Correlation between the win ratio of different models according to FID and PickScore to human experts on the MS-COCO validation set.
+
+![](images/10cdad832dac55d51a480b5f014fefed1ddf740d9da2bc0c3e6acb35962baf89.jpg)  
+Figure 7: Correlation between Elo ratings of real users and Elo ratings by CLIP-H, ImageReward [18], HPS [17], and PickScore.
+
+# 5 Model Evaluation
+
+Despite significant progress in the generative capabilities of text-to-image models, the standard and most popular prompt dataset has remained the Microsoft Common Objects in Context dataset (MS-COCO) [9]. Similarly, the Fréchet Inception Distance (FID) [5] is still the main metric used for model evaluation. In this section, we explain why we recommend researchers to evaluate their models using prompts from Pick-a-Pic rather than (or at least alongside) MS-COCO, and show that when evaluating state-of-the-art text-to-image models, PickScore is more aligned with human judgments than other automatic evaluation metrics.
+
+Model Evaluation Prompts The prompts contained in the MS-COCO dataset are captions of photographs taken by amateur photographers, depicting objects and humans in everyday settings. While certain captions within this dataset may pose a challenge to text-to-image models, it is evident that the scope of interest for text-to-image users extends beyond commonplace objects and humans. Moreover, the main use-case of image generation is arguably to generate fiction, which cannot be captured by camera. By construction, Pick-a-Pic’s prompts are sampled from real users, and thus better represent the natural distribution of text-to-image intents. We therefore strongly advocate that the research community employ prompts from Pick-a-Pic when assessing the performance of text-to-image models.
+
+FID The FID metric [5] gauges the degree of resemblance between a set of generated images and a set of authentic images, at the set level. To do so, it first embeds the real and generated images into the feature space of an Inception net [15], and then estimates the mean and covariance of both sets of images and calculates their similarity. FID is thus geared towards measuring the realism of a set of images, but is oblivious to the prompts. In contrast, PickScore provides a per-instance score, and is directly conditioned on the prompt. We thus hypothesize that PickScore will correlate better with human judgements of generation quality.
+
+To empirically test our hypothesis with the most “convenient” settings for the FID metric, we select 100 random captions from MS-COCO validation split. For each caption, we generate images from 9 different models based on the same set of prompts, and ask human experts to rank the 9 generated images (with ties), inducing pairwise preferences. Specifically, we use Stable Diffusion 1.5, Stable Diffusion 2.1, and Dreamlike Photoreal 2.0 combined with three different classifier-free guidance scales (3, 6, and 9). We then repeat the labeling process (over the same images) using FID, and PickScore instead of humans to determine preferences. Since FID does not operate on a per-example base, when “labeling” with FID, we simply choose the model that has a lower (better) FID score on MS-COCO.
+
+Figure 6 shows the correlation between model win rates induced by human rankings (horizontal) and model win rates induced by each automatic scoring function. PickScore exhibits a stronger correlation (0.917) with human raters on MS-COCO captions than FID (-0.900), which surprisingly, exhibits a strong negative correlation. As FID is oblivious to the prompt, one would expect zero correlation, and not a strong negative correlation. We hypothesize that this is related to the classifier-free guidance scale hyperparameter – larger scales tend to produce more vivid images (which humans typically prefer), but differ from the distribution of ground truth images in MS-COCO, yielding worse (higher) FID scores. Figure 5 visualizes these differences by presenting pairs of images generated with the same random seed but with different classifier-free guidance (CFG) scales.
+
+Other Evaluation Metrics When comparing with evaluation metrics that do not assume a set of ground truth images, we are able to use a more reliable evaluation procedure. In this evaluation procedure, we consider real user preferences rather than human annotators, as well as more models (i.e. more data points). Specifically, we take all the 14,000 collected preferences that correspond to prompts from the Pick-a-Pic test set. This set of examples contains images generated by 45 different models – four different backbone models, each with different guidance scales. We then use these real user preferences to calculate Elo ratings [4] for the different models. Afterward, we repeat the process while replacing the real user preferences with CLIP-H [7], and PickScore predictions. Similarly to Section 4, we also compare against the concurrent work from ImageReward[18] and HPS [17]. Since the Elo rating system is iterative by nature, we repeat the process 50 times. Each time we randomly shuffle the order of examples, and calculate the correlation with human ratings. Finally, for each metric, we output the mean and standard deviation of its 50 corresponding correlations. Figure 7 displays the correlation between real users’ Elo ratings with the different metrics’ rating, showing that PickScore exhibits a stronger correlation $( 0 . 7 9 0 \pm 0 . 0 5 4 )$ with real users than all other automatic metrics, namely CLIP-H $( 0 . 3 1 3 \pm 0 . 0 7 5 )$ , ImageReward $( 0 . 4 9 2 \pm 0 . 0 8 6 )$ , and HPS $( 0 . 6 7 0 \pm 0 . 0 7 1 )$ ).
+
+# 6 Text-to-Image Ranking
+
+Another possible application for scoring functions is improving the performance of generations made by text-to-image models through ranking: generate a sample of images, and select the one with the highest score. To test this approach, we generate one hundred images for each prompt of the one hundred prompts we take from the Pick-a-Pic test set. We generate the images with Dreamlike Photoreal 2.0, using a classifier-free guidance scale of 7.5, and to increase image diversity, we use 5 initial random noises and 20 different prompt templates. These templates include the null template “[prompt]” and other templates like “breathtaking [prompt]. award-winning, professional, highly detailed”. From each set of 100 generated images, we select the best one according to PickScore, CLIP-H, the aesthetics score, or randomly; in addition, we randomly select one image from the null template for control. We then ask expert human annotators to compare PickScore’s chosen image to each of the other functions’ choices, and decide which one they prefer.
+
+Table 2 shows that PickScore consistently selects more preferable images than the baselines. By manually analyzing some examples, we find that PickScore typically selects images that are both more aesthetic and better aligned with the prompt. We also measure this explicitly by using the aesthetic scoring function instead of a human rater when comparing PickScore’s choice to CLIP-H’s, and find that for $6 8 . 5 \%$ of the prompts, PickScore selects an image with a higher aesthetic score. Likewise, when comparing PickScore to the aesthetic scorer, $9 0 . 5 \%$ of PickScore’s choices have a higher CLIP-H text-alignment score than the images chosen by the aesthetic scorer. Figure 8 visualizes the benefits of selecting images with PickScore.
+
+Table 2: Percentage of instances where humans prefer PickScore’s choice over another scoring function’s choice when selecting one image out of 100.   
+
+<table><tr><td>Comparison</td><td>Win Rate</td></tr><tr><td>PickScore vs Random Seed + Null Template</td><td>71.4</td></tr><tr><td>+Random Template</td><td>82.0</td></tr><tr><td>PickScore Vs Aesthetics [14]</td><td>85.1</td></tr><tr><td>PickScore vs CLIP-H [7]</td><td>71.3</td></tr></table>
+
+![](images/57cf2bd40521c1878b141b39dba81f58d1ce5251af5484457054a70b48316035.jpg)  
+Figure 8: Comparing the image from the vanilla text-to-image model (left) with the image selected by PickScore from a set of 100 generations (right).
+
+# 7 Related Work
+
+Collecting and learning from human preferences is an active area of research in natural language processing (NLP) [3, 1, 10]. However, in the domain of text-to-image generation, related research questions have received little attention. One notable work that focuses on collecting human judgments in text-to-image generation is the Simulacra Aesthetic Captions (SAC) dataset [11]. This dataset contains almost 200,000 human ratings of generated images. However, unlike Pick-a-Pic which focuses on general user preferences, and allows users to compare between generated images, the human raters of SAC provide an absolute score for the aesthetic quality of the generated images.
+
+There has been some concurrent work that involves collection and learning from human preferences that we describe below. Lee et al. [8] consider three simple categories of challenges (count, color, and background), enumerating through templates (e.g. “[number] dogs”) to synthetically create prompts. Then, they instruct crowd workers to choose if a generated image is good or bad and use the collected 30,000 examples to train a scoring function. In contrast, Pick-a-Pick allows real users to write any prompts they choose, and provide pairwise comparisons between images that yield more than 500,000 examples.
+
+ImageReward [18] selects prompts and images from the DiffusionDB dataset [16], and collects for them image preference ratings via crowd workers. Since they employ crowd workers that lack the intrinsic motivation to select images that they prefer, the authors define criteria to assess the quality of generated images and instruct crowd workers to follow these criteria when ranking images. They use this strategy to collect 136,892 examples which originate from 8,878 prompts. Importantly, they have not publicly released this dataset. For completeness, we tested ImageReward on the Pick-a-Pic dataset and confirmed that PickScore outperforms it.
+
+Another concurrent work from Wu et al. [17] collects a dataset of human judgments by scraping about 25,000 human ratings (which include about 100,000 images) from the Discord channel of StabilityAI. Similarly to us, they use an objective analogous to that of InstructGPT to train a scoring function that they name Human Preference Score (HPS). As with ImageReward, we evaluated HPS on Pick-a-Pic and saw that PickScore achieves better performance.
+
+The observed superior performance of PickScore over the concurrent work from both HPS and ImageReward on the Pick-a-Pic dataset could be attributed to several factors. For example, differences in implementation (e.g., model size, backbone, hyperparameters), differences in the scales of data, or variations in the distribution of data. Notably, Pick-a-Pic is more than five times larger than the data used to train HPS and ImageReward. Furthermore, ImageReward collects judgments from crowd workers, which may lead to significant differences in data distribution. In contrast, HPS scrapes ratings from the StabilityAI discord channel for real text-to-image users but may be more aligned with this more specific distribution of text-to-image users. We leave Isolating and identifying the specific effects of these factors for future work.
+
+# 8 Limitations and Broader Impact
+
+It is important to acknowledge that despite our efforts to ensure data quality (see section 2), some images and prompts may contain NSFW content that could potentially bias the data, and some users may have made judgments without due care. Moreover, the preferences of users may include biases that may be reflected in the collected data. These limitations may affect the overall quality and reliability of the data collected and should be taken into consideration when considering the broader impact of the dataset. Nonetheless, we believe that the advantages of collecting data from intrinsically-motivated users and publicly releasing it will enable the text-to-image community to better align text-to-image models with human preferences.
+
+# 9 Conclusions
+
+We build a web application that serves text-to-image users and (willingly) collects their preferences. We use the collected data and present the Pick-a-Pic dataset: an open dataset of over half-a-million examples of text-to-image prompts, generated images, and user-labeled preferences. The quantity and quality of the data enables us to train PickScore, a state-of-the-art text-image scoring function, which achieves superhuman performance when predicting user preferences. PickScore aligns better with human judgements than any other publicly-available automatic metric, and together with Pick-a-Pic’s natural distribution prompts, enables much more relevant text-to-image model evaluation than existing evaluation standards, such as FID over MS-COCO. Finally, we demonstrate the effectiveness of using our scoring function for selecting images in improving the quality of text-to-image models. There are still many opportunities for building upon Pick-a-Pic and PickScore, such as RLHF and other alignment approaches, and we are excited to see how the research community will utilize this work in the near future.
+
+# References
+
+[1] Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, T. J. Henighan, Nicholas Joseph, Saurav Kadavath, John Kernion, Tom Conerly, Sheer El-Showk, Nelson Elhage, Zac Hatfield-Dodds, Danny Hernandez, Tristan Hume, Scott Johnston, Shauna Kravec, Liane Lovitt, Neel Nanda, Catherine Olsson, Dario Amodei, Tom B. Brown, Jack Clark, Sam McCandlish, Christopher Olah, Benjamin Mann, and Jared Kaplan. Training a helpful and harmless assistant with reinforcement learning from human feedback. ArXiv, abs/2204.05862, 2022.   
+[2] Xinlei Chen, Hao Fang, Tsung-Yi Lin, Ramakrishna Vedantam, Saurabh Gupta, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco captions: Data collection and evaluation server. ArXiv, abs/1504.00325, 2015.   
+[3] Paul Francis Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. ArXiv, abs/1706.03741, 2017.   
+[4] Arpad E. Elo. The rating of chessplayers, past and present. 1978.
+
+[5] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In NIPS, 2017.
+
+[6] Jonathan Ho. Classifier-free diffusion guidance. ArXiv, abs/2207.12598, 2022. [7] Gabriel Ilharco, Mitchell Wortsman, Ross Wightman, Cade Gordon, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, Hongseok Namkoong, John Miller, Hannaneh Hajishirzi, Ali Farhadi, and Ludwig Schmidt. Openclip, July 2021. If you use this software, please cite it as below. [8] Kimin Lee, Hao Liu, Moonkyung Ryu, Olivia Watkins, Yuqing Du, Craig Boutilier, P. Abbeel, Mohammad Ghavamzadeh, and Shixiang Shane Gu. Aligning text-to-image models using human feedback. ArXiv, abs/2302.12192, 2023. [9] Tsung-Yi Lin, Michael Maire, Serge J. Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   
+[10] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke E. Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul Francis Christiano, Jan Leike, and Ryan J. Lowe. Training language models to follow instructions with human feedback. ArXiv, abs/2203.02155, 2022.   
+[11] John David Pressman, Katherine Crowson, and Simulacra Captions Contributors. Simulacra aesthetic captions. Technical Report Version 1.0, Stability AI, 2022. url https://github.com/JD-P/simulacraaesthetic-captions .   
+[12] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, 2021.   
+[13] Robin Rombach, A. Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 10674–10685, 2021.   
+[14] Christoph Schuhmann, Romain Beaumont, Richard Vencu, Cade W Gordon, Ross Wightman, Mehdi Cherti, Theo Coombes, Aarush Katta, Clayton Mullis, Mitchell Wortsman, Patrick Schramowski, Srivatsa R Kundurthy, Katherine Crowson, Ludwig Schmidt, Robert Kaczmarczyk, and Jenia Jitsev. LAION-5b: An open large-scale dataset for training next generation image-text models. In Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2022.   
+[15] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2818–2826, 2015.   
+[16] Zijie J. Wang, Evan Montoya, David Munechika, Haoyang Yang, Benjamin Hoover, and Duen Horng Chau. Diffusiondb: A large-scale prompt gallery dataset for text-to-image generative models. ArXiv, abs/2210.14896, 2022.   
+[17] Xiaoshi Wu, Keqiang Sun, Feng Zhu, Rui Zhao, and Hongsheng Li. Better aligning text-to-image models with human preference. ArXiv, abs/2303.14420, 2023.   
+[18] Jiazheng Xu, Xiao Liu, Yuchen Wu, Yuxuan Tong, Qinkai Li, Ming Ding, Jie Tang, and Yuxiao Dong. Imagereward: Learning and evaluating human preferences for text-to-image generation. ArXiv, abs/2304.05977, 2023.
+
+# Appendix
+
+# Comparing Pick-a-Pic Prompts with MS-COCO Captions
+
+To illustrate the difference between MS-COCO captions and Pick-a-Pic prompts we show prompts from each dataset.
+
+Pick-a-Pic – “forest with ruins, photo”, “A panda bear as a mad scientist”, “product photo of a sneakers”, “photo of a bicycle, detailed, 8k uhd, dslr, high quality, film grain, Fujifilm XT3”, “female portrait photo”, “Alexander the great, cover art, colorful”, “A galactic eldritch squid towering over the planet Earth, stars, galaxies and nebulas in the background...”, “Portrait of a giant, fluffy, ninja teddy bear”, “insanely detailed portrait, darth vader, shiny, extremely intricate, high res, 8k, award winning”, “Giant ice cream cone melting and creating a river through a city”.
+
+MS-COCO – “A man with a red helmet on a small moped on a dirt road.”, “A woman wearing a net on her head cutting a cake.”, “there is a woman that is cutting a white cake”, “a little boy wearing headphones and looking at a computer monitor”, “A young girl is preparing to blow out her candle.”, “A commercial stainless kitchen with a pot of food cooking.”, “Two men that are standing in a kitchen.”, “A man riding a bike past a train traveling along tracks.”, “The pantry door of the small kitchen is closed.”, “A man is doing a trick on a skateboard”.
+
+# Training a Scoring Function
+
+We further explored an alternative loss function that is closer to CLIP’s original objective. In this loss function, we also incorporate the remaining examples in the batch as in-batch negatives. To elaborate, considering the notation established in section 3 and $y _ { 1 } ^ { k } , y _ { 2 } ^ { k }$ denoting the images corresponding to the $k$ -th example in the batch, we formulate $\hat { p } ^ { k }$ as follows:
+
+$$
+\hat { p } _ { i } ^ { k } = \frac { \exp { s ( x , y _ { i } ) } } { \sum _ { k } \sum _ { j = 1 } ^ { 2 } \exp { s ( x , y _ { j } ^ { k } ) } }
+$$
+
+We anticipated that this objective function would maintain the general capabilities of CLIP with minimal loss in performance. However, our findings demonstrated that PickScore significantly outperforms this objective function, as the latter only produced a scoring function that achieves an accuracy of 65.2 on the Pick-a-Pic test set.

parse/dev/G5RwHpBUv0/G5RwHpBUv0_content_list.json

@@ -0,0 +1,1074 @@
+[
+    {
+        "type": "text",
+        "text": "Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            122,
+            816,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuval Kirstainτ Adam Polyakτ Uriel Singer ",
+        "bbox": [
+            333,
+            224,
+            668,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shahbuland Matianaσ Joe Pennaσ Omer Levyτ ",
+        "bbox": [
+            320,
+            252,
+            676,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "τ Tel Aviv University σ Stability AI yuval.kirstain@cs.tau.ac.il ",
+        "bbox": [
+            382,
+            280,
+            614,
+            323
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            358,
+            535,
+            375
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability to collect a large dataset of human preferences from text-to-image users is usually limited to companies, making such datasets inaccessible to the public. To address this issue, we create a web app that enables text-to-image users to generate images and specify their preferences. Using this web app we build Pick-a-Pic, a large, open dataset of text-to-image prompts and real users’ preferences over generated images. We leverage this dataset to train a CLIP-based scoring function, PickScore, which exhibits superhuman performance on the task of predicting human preferences. Then, we test PickScore’s ability to perform model evaluation and observe that it correlates better with human rankings than other automatic evaluation metrics. Therefore, we recommend using PickScore for evaluating future text-to-image generation models, and using Pick-a-Pic prompts as a more relevant dataset than MS-COCO. Finally, we demonstrate how PickScore can enhance existing text-to-image models via ranking.1 ",
+        "bbox": [
+            233,
+            396,
+            766,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/564557e489507874f20b9dc4441e985237ef1c196efa6e1538412840ae5e4a7a.jpg",
+        "image_caption": [
+            "Figure 1: Images generated via our web application, showing darkened non-preferred images (left) and preferred images (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            611,
+            823,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            106
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in aligning language models with user behaviors and expectations have placed a significant emphasis on the ability to model user preferences [10, 1, 3]. However, little attention has been paid to this ability in the realm of text-to-image generation. This lack of attention can largely be attributed to the absence of a large and open dataset of human preferences over state-of-the-art image generation models. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            207
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To fill this void, we create a web application that enables users to generate images using state-of-theart text-to-image models while specifying their preferences. With explicit consent from the users, we collect their prompts and preferences to create Pick-a-Pic, a publicly available dataset comprising over half-a-million examples of human preferences over model-generated images.2 Each example in our dataset includes a prompt, two generated images, and a label indicating the preferred image, or a tie when no image is significantly preferred over the other. Notably, Pick-a-Pic was created by real users with a genuine interest in generating images. This interest differs from that of crowd workers who lack the intrinsic motivation to produce creative prompts or the original intent of the prompt’s author to judge which image better aligns with their needs. ",
+        "bbox": [
+            174,
+            213,
+            825,
+            338
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Tapping into authentic user preferences allows us to train a scoring function that estimates the user’s satisfaction from a particular generated image given a prompt. To train such a scoring function we finetune CLIP-H [12, 7] using human preference data and an analogous objective to that of InstructGPT’s reward model [10]. This objective aims to maximize the probability of a preferred image being picked over an unpreferred one, or even the probability in cases of a tie. We find that the resulting scoring function, PickScore3, achieves superhuman performance in the task of predicting user preferences (a $70 . 5 \\%$ accuracy rate, compared to humans’ $6 8 . 0 \\%$ ), while zero-shot CLIP-H $( 6 0 . 8 \\% )$ and the popular aesthetics predictor [14] $( 5 6 . 8 \\% )$ perform closer to chance $( 5 6 . 8 \\% )$ . ",
+        "bbox": [
+            174,
+            344,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Equipped with a dataset for human preferences and a state-of-the-art scoring function, we propose updating the standard protocol for evaluating text-to-image generation models. First, we suggest that researchers evaluate their text-to-image models using prompts from Pick-a-Pic, which better represent what humans want to generate than mundane captions, such as those found in MS-COCO [2, 9]. Second, to compare PickScore with FID, we conduct a human evaluation study and find that even when evaluated against MS-COCO captions, PickScore exhibits a strong correlation with human preferences (0.917), while ranking with FID yields a negative correlation (-0.900). Importantly, we also compare PickScore with other evaluation metrics using model rankings inferred from real user preferences. We observe that PickScore is more strongly correlated with ground truth rankings, as determined by real users, than other evaluation metrics. Thus, we recommend using PickScore as a more reliable evaluation metric than existing ones. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we explore how PickScore can improve the quality of vanilla text-to-image models via ranking. To accomplish this, we generate images with different initial random noises as well as different templates (e.g. “breathtaking [prompt]. award-winning, professional, highly detailed”) to slightly alter the user prompt. We then test the impact of selecting the top image according to different scoring functions. Our findings indicate that human raters prefer images selected by PickScore more than those selected by CLIP-H [7] (win rate of $7 1 . 3 \\%$ ), an aesthetics predictor [14] (win rate of $8 5 . 1 \\%$ , and the vanilla text-to-image model (win rate of $7 1 . 4 \\%$ ). ",
+        "bbox": [
+            174,
+            621,
+            825,
+            718
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, the presented work addresses a gap in the field of text-to-image generation by creating a large, open, high-quality dataset of human preferences over user-prompted model-generated images. We demonstrate the potential of this dataset by training a scoring function, PickScore, which exhibits a performance superior to any other publicly-available automatic scoring function, in predicting human preferences, evaluating text-to-image models, and improving them via ranking. We encourage the research community to adopt Pick-a-Pic and PickScore as a basis for further advances in text-to-image modeling and incorporating human preferences into the learning process. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f1c8249c412f1f948bb2399461429fe94f8eeb6587a76471d1f73fef2cc8abb.jpg",
+        "image_caption": [
+            "Figure 2: How Pick-a-Pic data is collected through the app: (a) the user first writes a caption, and receives two images; (b) the user makes a preference judgment; (c) a new image is presented instead of the rejected image. This flow repeats itself until the user changes the prompt. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            821,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Pick-a-Pic Dataset ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            357,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Pick-a-Pic dataset4 was created by logging user interactions with the Pick-a-Pic web application for text-to-image generation. Overall, the Pick-a-Pic dataset contains over 500,000 examples and 35,000 distinct prompts. Each example contains a prompt, two generated images, and a label for which image is preferred, or if there is a tie when no image is significantly preferred over the other. The images in the dataset were generated by employing multiple backbone models, namely, Stable Diffusion 2.1, Dreamlike Photoreal $2 . 0 ^ { 5 }$ , and Stable Diffusion XL variants [13] while sampling different classifier-free guidance scale values [6]. As we continue with our efforts to collect more user interactions through the Pick-a-Pic web app and decrease the number of NSFW examples included in the dataset, we will periodically upload new revisions of the dataset. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Pick-a-Pic Web App To ensure maximum accessibility for a wide range of users, the user interface was designed with simplicity in mind. The application allows users to write creative prompts and generate images. At each turn, the user is presented with two generated images (conditioned on their prompt), and asked to select their preferred option or indicate a tie if they have no strong preference. Upon selection, the rejected (non-preferred) image is replaced with a newly generated image, and the process repeats. The user can also clear or edit the prompt at any time, and the app will generate new images appropriately. Figure 2 illustrates the usage flow. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Real Data from Real Users A key advantage of Pick-a-Pic is that our data is collected from real, intrinsically-motivated users, rather than paid crowd workers. We achieve this by approaching a wide audience through various social media channels such as Twitter, Facebook, Discord, and Reddit. At the same time, we mitigate the risk of collecting low-quality data resulting from potential misuse of the application by implementing several quality control measures. First, users are required to authenticate their identity using either a Gmail or a Discord account.6 Second, we closely monitor user activity logs and take action to ban users who generate NSFW content, use multiple instances of the web app simultaneously, or make judgments at an unreasonably fast pace. Third, we use a list of NSFW phrases to prevent users from generating harmful content. Last, we limit users to 1000 interactions and periodically increase the limit. These measures work in tandem to ensure the integrity and reliability of Pick-a-Pic’s data. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            777
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Annotation Methodology While piloting the web app, we experimented with different annotation strategies to optimize for data quality, efficiency of collection, and user experience. Specifically, we tested the following annotation options: (1) 4 images, no ties; (2) 2 images, no ties; (3) 2 images, ",
+        "bbox": [
+            176,
+            792,
+            823,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6615d8f4afc55088183eb137afcc1688419bf3bcc1608706d11628e7e775d08b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            604,
+            99,
+            730,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea1558bc4e7d938d5ae4ce2f4af5efd3fc4bc1d71a13c07ffcd04d4b8da208ec.jpg",
+        "image_caption": [
+            "Figure 3: The Pick-a-Pic dataset enables us to perform model selection (a), and model evaluation (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            114,
+            408,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) Win rate versus classifier-free guidance scale for Stable Diffusion XL (Alpha). ",
+        "bbox": [
+            173,
+            218,
+            488,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(b) Preference distribution when comparing Stable Diffusion 2.1 with Dreamlike Photoreal 2.0. ",
+        "bbox": [
+            509,
+            218,
+            825,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with ties. We found that the latter option (2 images, with ties) exceeds the other two in terms of user engagement and inter-rater agreement. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Preprocessing When processing the collected interactions, we filter prompts with NSFW phrases and banned users. We acknowledge that there are still NSFW images and prompts, and will periodically attempt to update the dataset and reduce such occurrences. To divide the dataset into training, validation, and testing subsets, we first sample one thousand prompts, ensuring that each prompt was created by a unique user. Next, we randomly divide those prompts into two sets of equal size to create the validation and test sets. We then sample exactly one example for each prompt to include in these sets. For the training set, we include all examples that do not share a prompt with the validation and test sets. This approach ensures that no split shares prompts with another split, and the validation and test sets do not suffer from being non-proportionally fitted to a specific prompt or user. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Statistics Since the creation of the Pick-a-Pic web app we have gathered 968,965 rankings which originated from 66,798 prompts and 6,394 users. However, as the Pick-a-Pic dataset is constantly updating, the reported experiments in this paper involve an NSFW filtered and not fully updated version of Pick-a-Pic, that contains 583,747 training examples, and 500 validation and test examples. The training set of this dataset contains 37,523 prompts from 4,375 distinct users. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model Selection and Evaluation The Pick-a-Pic dataset offers a unique opportunity for a model selection and evaluation methodology, leveraging users’ preferences for unbiased analysis. To illustrate this opportunity, we use the collected data and analyze the impact of changing the classifierfree guidance scale of Stable Diffusion XL (Alpha variant) on its performance. Specifically, we compare human preferences made when both images were generated by Stable Diffusion XL (Alpha variant) but using different classifier-free guidance scales7. For each scale, we compute the win ratio, representing the percentage of judgments where its use led to a preferred image. We also calculate the corresponding tie and lose ratios for each scale, enabling a detailed analysis of which classifier-free guidance scales are more effective. Our results are depicted in Figure 3 (a), and verify for example, that a guidance scale of 9 usually yields preferred images when compared to a guidance scale of 3. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, by examining user preferences between images generated by different backbone models, we can determine which model is preferred more by users. For instance, considering judgments in which one image was generated by Dreamlike Photoreal 2.0 and the other by Stable Diffusion 2.1, we can evaluate which model is more performant. As shown in fig. 3 (b), users usually prefer Dreamlike Photoreal 2.0 over Stable Diffusion 2.1. We encourage researchers to contact us and include their text-to-image models in the Pick-a-Pic web app for the purpose of model selection and evaluation. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 PickScore ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            811,
+            287,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One valuable outcome from collecting a large, natural dataset of user preferences is that we can use it to train a function that scores the quality of a generated image given a prompt. We train the PickScore scoring function over Pick-a-Pic by combining a CLIP-style model with a variant of ",
+        "bbox": [
+            176,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "InstructGPT’s reward model objective [10]. PickScore is able to predict user preferences in held-out Pick-a-Pic prompts better than any other publicly-available scoring function, surpassing even expert human annotators (Section 4). Such a scoring function can be of value for various scenarios, such as performing model evaluation (Section 5), increasing the quality of generated images via ranking (Section 6), building better large-scale datasets to improve text-to-image models [14], and improving text-to-image models through weak supervision (e.g. RLHF). ",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Model PickScore follows the architecture of CLIP [12]; given a prompt $x$ and an image $y$ , our scoring function $s$ computes a real number by representing $x$ using a transformer text encoder and $y$ using a transformer image encoder as $d$ -dimensional vectors, and returning their inner product: ",
+        "bbox": [
+            174,
+            189,
+            823,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0e9f13b349217ead6a140571f8bc569020a4d0567482c57be5bb33bba1f72e6.jpg",
+        "text": "$$\ns ( x , y ) = E _ { \\mathrm { t x t } } ( x ) \\cdot E _ { \\mathrm { i m g } } ( y ) \\cdot T\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            239,
+            602,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where $T$ is the learned scalar temperature parameter of CLIP. ",
+        "bbox": [
+            173,
+            265,
+            578,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Objective The input for our objective includes a scoring function $s$ , a prompt $x$ , two images $y _ { 1 } , y _ { 2 }$ , and a preference distribution vector $p$ , which captures the user’s preference over the two images. Specifically, $p$ takes a value of $[ 1 , 0 ]$ if $y _ { 1 }$ is preferred, $[ 0 , 1 ]$ if $y _ { 2 }$ is preferred, or [0.5, 0.5] for ties. Given this input, the objective optimizes the scoring function’s parameters by minimizing the KL-divergence between the preference $p$ and the softmax-normalized scores of $y _ { 1 }$ and $y _ { 2 }$ : ",
+        "bbox": [
+            174,
+            295,
+            825,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f4460f28b14d7066fbcdae0f53d3243d6fb30ee79139c6592512de0e8bf1641.jpg",
+        "text": "$$\n\\hat { p } _ { i } = \\frac { \\exp s ( x , y _ { i } ) } { \\sum _ { j = 1 } ^ { 2 } \\exp s ( x , y _ { j } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            372,
+            581,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9c03f2b9675a4f3e4133fd226ac3fad4f9d43d2cc1b7aa5a5ea4aa08907c4d0.jpg",
+        "text": "$$\n{ L _ { \\mathrm { p r e f } } = \\sum _ { i = 1 } ^ { 2 } p _ { i } \\left( \\log p _ { i } - \\log \\hat { p } _ { i } \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            419,
+            601,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since many examples can originate from the same prompt, we mitigate the risk of overfitting to a small set of prompts by applying a weighted average when reducing the loss across examples in the batch. Specifically, we weigh each example in the batch, with an inverse proportion to its prompt frequency in the dataset. This objective is analogous to InstructGPT’s reward model objective [10]. We also experiment with incorporating in-batch negatives into the objective, but find that this yields a less accurate scoring function (see Appendix). ",
+        "bbox": [
+            173,
+            465,
+            825,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training We finetune CLIP-H [7] using our framework8 on the Pick-a-Pic training set. We train the model for 4,000 steps, with a learning rate of 3e-6, a total batch size of 128, and a warmup period of 500 steps, which follows a linearly decaying learning rate; the experiment is completed in less than an hour with 8 A100 GPUs. We did not perform hyperparameter search, which might further improve results. For model selection, we evaluate the model’s accuracy on the validation set (without the option for a tie) in intervals of 100 steps, and keep the best-performing checkpoint. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Preference Prediction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            387,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate PickScore on the task it was trained to do: predict human preferences. We find that PickScore outperforms all other baselines, including expert human annotators. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Metric To evaluate the ability of models to predict human preferences, we use an adapted accuracy metric that accounts for the possibility of a tie. Our metric assigns one point to the model for predicting the same label as the user, half a point if either label or prediction is a tie (but not both), and zero otherwise. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Tie Threshold Selection Utilizing the notation specified in Section 3, each model requires a tie threshold probability $t$ to predict a tied outcome when $| \\hat { p } _ { 1 } - \\hat { p } _ { 2 } | < t$ . To achieve this, we evaluate each model on the validation set using various tie threshold probabilities and subsequently determine the most optimal tie threshold for each model. For human experts, we do not perform tie selection and explicitly allow them to select a tie. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f2a5b680227fc5555664385601d9d911f6c233975c5110318349257d8bc1246.jpg",
+        "image_caption": [
+            "Figure 4: Disagreement between CLIP-H (left) and PickScore (right) on the Pick-a-Pic validation set. We add green borders around images that humans preferred. ",
+            "Table 1: Quantitative results on Pick-a-Pic. ",
+            "(a) Accuracy across different tie thresholds on the Pick-a-Pic validation set "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            111,
+            537,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e474fbe1c1382557c67a3e7a78313cb58d48d0b60f497c689608db2e1fdf5502.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            580,
+            122,
+            794,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/99a663521299f42ca8235e98af8d3eba9b251e4af06431aa198d210dfd6de517.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Performance on the Pick-a-Pic test set. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy</td></tr><tr><td>Random Human Expert</td><td>56.8 68.0</td></tr><tr><td>Aesthetics [14]</td><td>56.8</td></tr><tr><td>CLIP-H[7]</td><td>60.8</td></tr><tr><td>ImageReward [18]</td><td>61.1</td></tr><tr><td>HPS [17]</td><td>66.7</td></tr><tr><td>PickScore (Ours)</td><td>70.5</td></tr></table>",
+        "bbox": [
+            589,
+            304,
+            784,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare our model with CLIP-H [7], an aesthetics predictor [14] built on top of CLIP-L [12], a random classifier, and human experts.9 For completeness, we also compare our results with models from concurrent work, namely, HPS [17] and ImageReward [18]. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results First, we compare the models’ performance on the validation set across different tie thresholds. Figure 1a shows that PickScore outperforms the baselines across almost all thresholds, and achieves the highest global score by a wide margin. After selecting the best-performing tie threshold for each model, we use the threshold to evaluate the different models on the test set. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1b shows that the aesthetics score (56.8) and CLIP-H (60.8) perform closer to a random chance baseline (56.8), while PickScore $( 7 0 . 5 \\pm 0 . 1 4 2 ) ^ { 1 0 }$ achieves superhuman performance, as it even outperforms human experts (68.0). It is important to emphasize a core difference between real users that produce the ground truth labels and annotators used to evaluate human performance. The users that produce the ground truth are actual text-to-image users, which have an idea (which may be incomplete) for an image, and invent a prompt (which may lack details) with hope that the resulting image will match their preferences. In contrast, annotators that are used to measure human performance are oblivious to the original user’s context, idea, and motivation. Therefore, superhuman performance on this task means that the model is able to outperform a human annotator that is oblivious to the original user’s context, idea, and motivation. The superhuman performance of PickScore showcases the importance of using real users as ground truth rather than expert annotators when collecting human preferences. Moreover, the relatively modest human performance (68.0) on the task, when compared to a random baseline (56.8), shows that predicting human preferences in text-to-image generation is a difficult task for human annotators. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For completeness, we also include the results of concurrent work from HPS [17], which scores 66.7, and ImageReward [18], which scores 61.1; PickScore outperforms both. To further illustrate the differences between CLIP-H and PickScore, we showcase examples of disagreement from the Pick-a-Pic validation set in Figure 4. We notice that PickScore often chooses more aesthetically pleasing images than CLIP-H; at times, at the cost of faithfulness to the prompt. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/99cadb8ca71029811819199799e68e1edea3c264eebdc59f89766d61f322760b.jpg",
+        "image_caption": [
+            "Figure 5: Images generated using the same seed and model, but using different classifier-free guidance (CFG) scales. Even though high guidance scales lead to worse FID, humans usually find them more pleasing than low guidance scales. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            92,
+            552,
+            351
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bb28f42655114880fc91f20aa4cbafa0524ce03842af7ee4cfe0777b4d278be.jpg",
+        "image_caption": [
+            "Figure 6: Correlation between the win ratio of different models according to FID and PickScore to human experts on the MS-COCO validation set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            103,
+            797,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/10cdad832dac55d51a480b5f014fefed1ddf740d9da2bc0c3e6acb35962baf89.jpg",
+        "image_caption": [
+            "Figure 7: Correlation between Elo ratings of real users and Elo ratings by CLIP-H, ImageReward [18], HPS [17], and PickScore. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            441,
+            816,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Model Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            601,
+            354,
+            618
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Despite significant progress in the generative capabilities of text-to-image models, the standard and most popular prompt dataset has remained the Microsoft Common Objects in Context dataset (MS-COCO) [9]. Similarly, the Fréchet Inception Distance (FID) [5] is still the main metric used for model evaluation. In this section, we explain why we recommend researchers to evaluate their models using prompts from Pick-a-Pic rather than (or at least alongside) MS-COCO, and show that when evaluating state-of-the-art text-to-image models, PickScore is more aligned with human judgments than other automatic evaluation metrics. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model Evaluation Prompts The prompts contained in the MS-COCO dataset are captions of photographs taken by amateur photographers, depicting objects and humans in everyday settings. While certain captions within this dataset may pose a challenge to text-to-image models, it is evident that the scope of interest for text-to-image users extends beyond commonplace objects and humans. Moreover, the main use-case of image generation is arguably to generate fiction, which cannot be captured by camera. By construction, Pick-a-Pic’s prompts are sampled from real users, and thus better represent the natural distribution of text-to-image intents. We therefore strongly advocate that the research community employ prompts from Pick-a-Pic when assessing the performance of text-to-image models. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            868
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "FID The FID metric [5] gauges the degree of resemblance between a set of generated images and a set of authentic images, at the set level. To do so, it first embeds the real and generated images into the feature space of an Inception net [15], and then estimates the mean and covariance of both sets of images and calculates their similarity. FID is thus geared towards measuring the realism of a set of images, but is oblivious to the prompts. In contrast, PickScore provides a per-instance score, and is directly conditioned on the prompt. We thus hypothesize that PickScore will correlate better with human judgements of generation quality. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To empirically test our hypothesis with the most “convenient” settings for the FID metric, we select 100 random captions from MS-COCO validation split. For each caption, we generate images from 9 different models based on the same set of prompts, and ask human experts to rank the 9 generated images (with ties), inducing pairwise preferences. Specifically, we use Stable Diffusion 1.5, Stable Diffusion 2.1, and Dreamlike Photoreal 2.0 combined with three different classifier-free guidance scales (3, 6, and 9). We then repeat the labeling process (over the same images) using FID, and PickScore instead of humans to determine preferences. Since FID does not operate on a per-example base, when “labeling” with FID, we simply choose the model that has a lower (better) FID score on MS-COCO. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the correlation between model win rates induced by human rankings (horizontal) and model win rates induced by each automatic scoring function. PickScore exhibits a stronger correlation (0.917) with human raters on MS-COCO captions than FID (-0.900), which surprisingly, exhibits a strong negative correlation. As FID is oblivious to the prompt, one would expect zero correlation, and not a strong negative correlation. We hypothesize that this is related to the classifier-free guidance scale hyperparameter – larger scales tend to produce more vivid images (which humans typically prefer), but differ from the distribution of ground truth images in MS-COCO, yielding worse (higher) FID scores. Figure 5 visualizes these differences by presenting pairs of images generated with the same random seed but with different classifier-free guidance (CFG) scales. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            422
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Other Evaluation Metrics When comparing with evaluation metrics that do not assume a set of ground truth images, we are able to use a more reliable evaluation procedure. In this evaluation procedure, we consider real user preferences rather than human annotators, as well as more models (i.e. more data points). Specifically, we take all the 14,000 collected preferences that correspond to prompts from the Pick-a-Pic test set. This set of examples contains images generated by 45 different models – four different backbone models, each with different guidance scales. We then use these real user preferences to calculate Elo ratings [4] for the different models. Afterward, we repeat the process while replacing the real user preferences with CLIP-H [7], and PickScore predictions. Similarly to Section 4, we also compare against the concurrent work from ImageReward[18] and HPS [17]. Since the Elo rating system is iterative by nature, we repeat the process 50 times. Each time we randomly shuffle the order of examples, and calculate the correlation with human ratings. Finally, for each metric, we output the mean and standard deviation of its 50 corresponding correlations. Figure 7 displays the correlation between real users’ Elo ratings with the different metrics’ rating, showing that PickScore exhibits a stronger correlation $( 0 . 7 9 0 \\pm 0 . 0 5 4 )$ with real users than all other automatic metrics, namely CLIP-H $( 0 . 3 1 3 \\pm 0 . 0 7 5 )$ , ImageReward $( 0 . 4 9 2 \\pm 0 . 0 8 6 )$ , and HPS $( 0 . 6 7 0 \\pm 0 . 0 7 1 )$ ). ",
+        "bbox": [
+            173,
+            438,
+            825,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Text-to-Image Ranking ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            400,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another possible application for scoring functions is improving the performance of generations made by text-to-image models through ranking: generate a sample of images, and select the one with the highest score. To test this approach, we generate one hundred images for each prompt of the one hundred prompts we take from the Pick-a-Pic test set. We generate the images with Dreamlike Photoreal 2.0, using a classifier-free guidance scale of 7.5, and to increase image diversity, we use 5 initial random noises and 20 different prompt templates. These templates include the null template “[prompt]” and other templates like “breathtaking [prompt]. award-winning, professional, highly detailed”. From each set of 100 generated images, we select the best one according to PickScore, CLIP-H, the aesthetics score, or randomly; in addition, we randomly select one image from the null template for control. We then ask expert human annotators to compare PickScore’s chosen image to each of the other functions’ choices, and decide which one they prefer. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows that PickScore consistently selects more preferable images than the baselines. By manually analyzing some examples, we find that PickScore typically selects images that are both more aesthetic and better aligned with the prompt. We also measure this explicitly by using the aesthetic scoring function instead of a human rater when comparing PickScore’s choice to CLIP-H’s, and find that for $6 8 . 5 \\%$ of the prompts, PickScore selects an image with a higher aesthetic score. Likewise, when comparing PickScore to the aesthetic scorer, $9 0 . 5 \\%$ of PickScore’s choices have a higher CLIP-H text-alignment score than the images chosen by the aesthetic scorer. Figure 8 visualizes the benefits of selecting images with PickScore. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e86221fea04eb8f40fd53fca77af1befb9aa9bf5b8251c6f8d3fb762d28373fc.jpg",
+        "table_caption": [
+            "Table 2: Percentage of instances where humans prefer PickScore’s choice over another scoring function’s choice when selecting one image out of 100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Comparison</td><td>Win Rate</td></tr><tr><td>PickScore vs Random Seed + Null Template</td><td>71.4</td></tr><tr><td>+Random Template</td><td>82.0</td></tr><tr><td>PickScore Vs Aesthetics [14]</td><td>85.1</td></tr><tr><td>PickScore vs CLIP-H [7]</td><td>71.3</td></tr></table>",
+        "bbox": [
+            369,
+            133,
+            625,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/57cf2bd40521c1878b141b39dba81f58d1ce5251af5484457054a70b48316035.jpg",
+        "image_caption": [
+            "Figure 8: Comparing the image from the vanilla text-to-image model (left) with the image selected by PickScore from a set of 100 generations (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            263,
+            807,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            487,
+            825,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            321,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Collecting and learning from human preferences is an active area of research in natural language processing (NLP) [3, 1, 10]. However, in the domain of text-to-image generation, related research questions have received little attention. One notable work that focuses on collecting human judgments in text-to-image generation is the Simulacra Aesthetic Captions (SAC) dataset [11]. This dataset contains almost 200,000 human ratings of generated images. However, unlike Pick-a-Pic which focuses on general user preferences, and allows users to compare between generated images, the human raters of SAC provide an absolute score for the aesthetic quality of the generated images. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There has been some concurrent work that involves collection and learning from human preferences that we describe below. Lee et al. [8] consider three simple categories of challenges (count, color, and background), enumerating through templates (e.g. “[number] dogs”) to synthetically create prompts. Then, they instruct crowd workers to choose if a generated image is good or bad and use the collected 30,000 examples to train a scoring function. In contrast, Pick-a-Pick allows real users to write any prompts they choose, and provide pairwise comparisons between images that yield more than 500,000 examples. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ImageReward [18] selects prompts and images from the DiffusionDB dataset [16], and collects for them image preference ratings via crowd workers. Since they employ crowd workers that lack the intrinsic motivation to select images that they prefer, the authors define criteria to assess the quality of generated images and instruct crowd workers to follow these criteria when ranking images. They use this strategy to collect 136,892 examples which originate from 8,878 prompts. Importantly, they have not publicly released this dataset. For completeness, we tested ImageReward on the Pick-a-Pic dataset and confirmed that PickScore outperforms it. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another concurrent work from Wu et al. [17] collects a dataset of human judgments by scraping about 25,000 human ratings (which include about 100,000 images) from the Discord channel of StabilityAI. Similarly to us, they use an objective analogous to that of InstructGPT to train a scoring function that they name Human Preference Score (HPS). As with ImageReward, we evaluated HPS on Pick-a-Pic and saw that PickScore achieves better performance. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The observed superior performance of PickScore over the concurrent work from both HPS and ImageReward on the Pick-a-Pic dataset could be attributed to several factors. For example, differences in implementation (e.g., model size, backbone, hyperparameters), differences in the scales of data, or variations in the distribution of data. Notably, Pick-a-Pic is more than five times larger than the data used to train HPS and ImageReward. Furthermore, ImageReward collects judgments from crowd workers, which may lead to significant differences in data distribution. In contrast, HPS scrapes ratings from the StabilityAI discord channel for real text-to-image users but may be more aligned with this more specific distribution of text-to-image users. We leave Isolating and identifying the specific effects of these factors for future work. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Limitations and Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            313,
+            477,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "It is important to acknowledge that despite our efforts to ensure data quality (see section 2), some images and prompts may contain NSFW content that could potentially bias the data, and some users may have made judgments without due care. Moreover, the preferences of users may include biases that may be reflected in the collected data. These limitations may affect the overall quality and reliability of the data collected and should be taken into consideration when considering the broader impact of the dataset. Nonetheless, we believe that the advantages of collecting data from intrinsically-motivated users and publicly releasing it will enable the text-to-image community to better align text-to-image models with human preferences. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "9 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            305,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We build a web application that serves text-to-image users and (willingly) collects their preferences. We use the collected data and present the Pick-a-Pic dataset: an open dataset of over half-a-million examples of text-to-image prompts, generated images, and user-labeled preferences. The quantity and quality of the data enables us to train PickScore, a state-of-the-art text-image scoring function, which achieves superhuman performance when predicting user preferences. PickScore aligns better with human judgements than any other publicly-available automatic metric, and together with Pick-a-Pic’s natural distribution prompts, enables much more relevant text-to-image model evaluation than existing evaluation standards, such as FID over MS-COCO. Finally, we demonstrate the effectiveness of using our scoring function for selecting images in improving the quality of text-to-image models. There are still many opportunities for building upon Pick-a-Pic and PickScore, such as RLHF and other alignment approaches, and we are excited to see how the research community will utilize this work in the near future. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            266,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, T. J. Henighan, Nicholas Joseph, Saurav Kadavath, John Kernion, Tom Conerly, Sheer El-Showk, Nelson Elhage, Zac Hatfield-Dodds, Danny Hernandez, Tristan Hume, Scott Johnston, Shauna Kravec, Liane Lovitt, Neel Nanda, Catherine Olsson, Dario Amodei, Tom B. Brown, Jack Clark, Sam McCandlish, Christopher Olah, Benjamin Mann, and Jared Kaplan. Training a helpful and harmless assistant with reinforcement learning from human feedback. ArXiv, abs/2204.05862, 2022.   \n[2] Xinlei Chen, Hao Fang, Tsung-Yi Lin, Ramakrishna Vedantam, Saurabh Gupta, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco captions: Data collection and evaluation server. ArXiv, abs/1504.00325, 2015.   \n[3] Paul Francis Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. ArXiv, abs/1706.03741, 2017.   \n[4] Arpad E. Elo. The rating of chessplayers, past and present. 1978. ",
+        "bbox": [
+            179,
+            719,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[5] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In NIPS, 2017. ",
+        "bbox": [
+            178,
+            92,
+            825,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[6] Jonathan Ho. Classifier-free diffusion guidance. ArXiv, abs/2207.12598, 2022. [7] Gabriel Ilharco, Mitchell Wortsman, Ross Wightman, Cade Gordon, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, Hongseok Namkoong, John Miller, Hannaneh Hajishirzi, Ali Farhadi, and Ludwig Schmidt. Openclip, July 2021. If you use this software, please cite it as below. [8] Kimin Lee, Hao Liu, Moonkyung Ryu, Olivia Watkins, Yuqing Du, Craig Boutilier, P. Abbeel, Mohammad Ghavamzadeh, and Shixiang Shane Gu. Aligning text-to-image models using human feedback. ArXiv, abs/2302.12192, 2023. [9] Tsung-Yi Lin, Michael Maire, Serge J. Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   \n[10] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke E. Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul Francis Christiano, Jan Leike, and Ryan J. Lowe. Training language models to follow instructions with human feedback. ArXiv, abs/2203.02155, 2022.   \n[11] John David Pressman, Katherine Crowson, and Simulacra Captions Contributors. Simulacra aesthetic captions. Technical Report Version 1.0, Stability AI, 2022. url https://github.com/JD-P/simulacraaesthetic-captions .   \n[12] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, 2021.   \n[13] Robin Rombach, A. Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 10674–10685, 2021.   \n[14] Christoph Schuhmann, Romain Beaumont, Richard Vencu, Cade W Gordon, Ross Wightman, Mehdi Cherti, Theo Coombes, Aarush Katta, Clayton Mullis, Mitchell Wortsman, Patrick Schramowski, Srivatsa R Kundurthy, Katherine Crowson, Ludwig Schmidt, Robert Kaczmarczyk, and Jenia Jitsev. LAION-5b: An open large-scale dataset for training next generation image-text models. In Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2022.   \n[15] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2818–2826, 2015.   \n[16] Zijie J. Wang, Evan Montoya, David Munechika, Haoyang Yang, Benjamin Hoover, and Duen Horng Chau. Diffusiondb: A large-scale prompt gallery dataset for text-to-image generative models. ArXiv, abs/2210.14896, 2022.   \n[17] Xiaoshi Wu, Keqiang Sun, Feng Zhu, Rui Zhao, and Hongsheng Li. Better aligning text-to-image models with human preference. ArXiv, abs/2303.14420, 2023.   \n[18] Jiazheng Xu, Xiao Liu, Yuchen Wu, Yuxuan Tong, Qinkai Li, Ming Ding, Jie Tang, and Yuxiao Dong. Imagereward: Learning and evaluating human preferences for text-to-image generation. ArXiv, abs/2304.05977, 2023. ",
+        "bbox": [
+            169,
+            101,
+            828,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Appendix ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            258,
+            107
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Comparing Pick-a-Pic Prompts with MS-COCO Captions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            119,
+            580,
+            135
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To illustrate the difference between MS-COCO captions and Pick-a-Pic prompts we show prompts from each dataset. ",
+        "bbox": [
+            176,
+            145,
+            823,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pick-a-Pic – “forest with ruins, photo”, “A panda bear as a mad scientist”, “product photo of a sneakers”, “photo of a bicycle, detailed, 8k uhd, dslr, high quality, film grain, Fujifilm XT3”, “female portrait photo”, “Alexander the great, cover art, colorful”, “A galactic eldritch squid towering over the planet Earth, stars, galaxies and nebulas in the background...”, “Portrait of a giant, fluffy, ninja teddy bear”, “insanely detailed portrait, darth vader, shiny, extremely intricate, high res, 8k, award winning”, “Giant ice cream cone melting and creating a river through a city”. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MS-COCO – “A man with a red helmet on a small moped on a dirt road.”, “A woman wearing a net on her head cutting a cake.”, “there is a woman that is cutting a white cake”, “a little boy wearing headphones and looking at a computer monitor”, “A young girl is preparing to blow out her candle.”, “A commercial stainless kitchen with a pot of food cooking.”, “Two men that are standing in a kitchen.”, “A man riding a bike past a train traveling along tracks.”, “The pantry door of the small kitchen is closed.”, “A man is doing a trick on a skateboard”. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Training a Scoring Function ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            372,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We further explored an alternative loss function that is closer to CLIP’s original objective. In this loss function, we also incorporate the remaining examples in the batch as in-batch negatives. To elaborate, considering the notation established in section 3 and $y _ { 1 } ^ { k } , y _ { 2 } ^ { k }$ denoting the images corresponding to the $k$ -th example in the batch, we formulate $\\hat { p } ^ { k }$ as follows: ",
+        "bbox": [
+            174,
+            393,
+            825,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d324710d1178ecf8807e27948c8f6ace66f4aa2b32f0875e081117fdb7dca50.jpg",
+        "text": "$$\n\\hat { p } _ { i } ^ { k } = \\frac { \\exp { s ( x , y _ { i } ) } } { \\sum _ { k } \\sum _ { j = 1 } ^ { 2 } \\exp { s ( x , y _ { j } ^ { k } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            458,
+            598,
+            497
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We anticipated that this objective function would maintain the general capabilities of CLIP with minimal loss in performance. However, our findings demonstrated that PickScore significantly outperforms this objective function, as the latter only produced a scoring function that achieves an accuracy of 65.2 on the Pick-a-Pic test set. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            558
+        ],
+        "page_idx": 11
+    }
+]

parse/dev/QJb1-8NH2Ux/QJb1-8NH2Ux_content_list.json

@@ -0,0 +1,1839 @@
+[
+    {
+        "type": "text",
+        "text": "DETECTING ADVERSARIAL EXAMPLES IS (NEARLY) AS HARD AS CLASSIFYING THEM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Making classifiers robust to adversarial examples is challenging. Thus, many defenses tackle the seemingly easier task of detecting perturbed inputs. ",
+        "bbox": [
+            232,
+            266,
+            763,
+            294
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show a barrier towards this goal. We prove a general hardness reduction between detection and classification of adversarial examples: given a robust detector for attacks at distance $\\epsilon$ (in some metric), we show how to build a similarly robust (but inefficient) classifier for attacks at distance $\\epsilon / 2$ —and vice-versa. ",
+        "bbox": [
+            232,
+            296,
+            764,
+            352
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our reduction is computationally inefficient, and thus cannot be used to build practical classifiers. Instead, it is a useful sanity check to test whether empirical detection results imply something much stronger than the authors presumably anticipated. ",
+        "bbox": [
+            233,
+            353,
+            764,
+            410
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To illustrate, we revisit 14 empirical detector defenses published over the past years. For $1 2 / 1 4$ defenses, we show that the claimed detection results imply an inefficient classifier with robustness far beyond the state-of-the-art— thus casting some doubts on the results’ validity. ",
+        "bbox": [
+            233,
+            411,
+            764,
+            467
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Finally, we show that our reduction applies in both directions: a robust classifier for attacks at distance $\\epsilon / 2$ implies an inefficient robust detector at distance \u000f. Thus, we argue that robust classification and robust detection should be regarded as (near)-equivalent problems, if we disregard their computational complexity. ",
+        "bbox": [
+            232,
+            469,
+            764,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            336,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Building models that are robust to adversarial examples (Szegedy et al., 2014; Biggio et al., 2013) is a major challenge and open-problem in machine learning. Due to the inherent difficulty in building robust classifiers, researchers have attempted to build techniques to at least detect adversarial examples, a weaker task that is largely considered easier than robust classification (Xu et al., 2018; Pang et al., 2021; Sheikholeslami et al., 2021). ",
+        "bbox": [
+            174,
+            582,
+            825,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yet, evaluating the robustness of empirical detector defenses is challenging. This is in part due to a lack of strong evaluation guidelines and benchmarks—akin to those developed for robust classifiers (Carlini et al., 2019; Croce et al., 2020)—as well as to a lack of long-standing comparative baselines such as adversarial training (Madry et al., 2018). ",
+        "bbox": [
+            174,
+            657,
+            825,
+            714
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To illustrate, consider the following (fictitious) claims about two defenses against adversarial examples on CIFAR-10: ",
+        "bbox": [
+            173,
+            720,
+            821,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• defense A is a classifier that achieves robust accuracy of $9 0 \\%$ under $\\ell _ { \\infty }$ -perturbations bounded by $\\epsilon = { } ^ { 4 } / 2 5 5$ ;   \n• defense B also has a “rejection” option, and achieves robust accuracy of $9 0 \\%$ under $\\ell _ { \\infty }$ - perturbations bounded by $\\epsilon = { \\bf 8 } / 2 5 5$ (we say that defense B is robust for some example if it classifies that example correctly, and either rejects/detects or correctly classifies all perturbed examples at distance $\\epsilon .$ .) ",
+        "bbox": [
+            218,
+            760,
+            825,
+            849
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Which of these two (empirical) claims are you more likely to believe to be correct? ",
+        "bbox": [
+            174,
+            859,
+            714,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Defense A claims much higher robustness than the current best result achieved with adversarial training (Madry et al., 2018; Rebuffi et al., 2021), the only empirical defense against adversarial examples that has stood the test of time. Indeed, the state-of-the-art $\\ell _ { \\infty }$ robustness for $\\epsilon = { ^ 4 } / { 2 5 } 5$ on CIFAR-10 (without external data) is $\\approx 7 9 \\%$ (Rebuffi et al., 2021). Thus, the claim of defense A would likely be met with some initial skepticism and heightened scrutiny, as could be expected for such a claimed breakthrough result. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The claim of defense B is harder to assess, due to a lack of long-standing baselines for robust detectors (many detection defenses have been shown to be broken (Carlini & Wagner, 2017; Tramer\\` et al., 2020)). On one hand, detection of adversarial examples has largely been considered to be an easier task than classification $\\mathrm { { X u } }$ et al., 2018; Pang et al., 2021; Sheikholeslami et al., 2021). On the other hand, defense B claims robustness to perturbations that are twice as large as defense A ${ \\bf \\zeta } ( \\epsilon = 8 / 2 5 5$ vs. $\\epsilon = 4 / 2 5 5$ ). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we show that the claims of defenses A and B are, in fact, equivalent! (up to computational efficiency.) ",
+        "bbox": [
+            176,
+            243,
+            821,
+            271
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We prove a general hardness reduction between classification and detection of adversarial examples. Given a detector defense that achieves robust risk $\\alpha$ for attacks at distance $\\epsilon$ (under any metric), we show how to build an explicit but inefficient classifier that achieves robust risk $\\alpha$ for classifying attacks at distance $\\epsilon / 2$ . The reverse implication also holds: a classifier robust at distance $\\epsilon / 2$ implies an explicit but inefficient robust detector at distance $\\epsilon$ . ",
+        "bbox": [
+            174,
+            279,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To the authors knowledge, there is no known way of leveraging computational inefficiency to build more robust models. We should thus be as “surprised” by the claim made by defense B as by the claim made by defense A. ",
+        "bbox": [
+            178,
+            356,
+            821,
+            397
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our reduction provides a way of assessing the plausibility of new robust detection claims, by contrasting them with results from the more mature literature on robust classification. To illustrate, we revisit 14 published detection defenses across three datasets, and show that in 12/14 cases the defense’s robust detection claims would imply an inefficient classifier with robustness far superior to the current state-of-the-art. Yet, none of these detection papers make the claim that their techniques should imply such a breakthrough in robust classification. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using our reduction, it is obvious that many detection defenses are claiming much stronger robustness than we believe feasible with current techniques. And indeed, many of these defenses were later shown to have overestimated their robustness (Carlini & Wagner, 2017; Tramer et al., 2020). \\` ",
+        "bbox": [
+            174,
+            494,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Remarkably, we find that for certified defenses, the state-of-the-art results for provable robust classification and detection perfectly match the results implied by our reduction. For example, Sheikholeslami et al. (2021) recently proposed a certified detector on CIFAR-10 with provable robust error that is within $3 \\%$ of the provable error of the inefficient detector obtained by combining our result with the state-of-the-art robust classifier of Zhang et al. (2020a). ",
+        "bbox": [
+            174,
+            544,
+            823,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we prove that giving classifiers access to a detection option does not help robustness (or at least, not much). Our work provides, to our knowledge, the first example of a hardness reduction between different approaches for robust machine learning. As in the case of computational complexity, we believe that such reductions can be useful for identifying research questions or areas that are unlikely to bear fruit (bar a significant breakthrough)—so that the majority of the community’s efforts can be redirected elsewhere. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On a technical level, our reduction exposes a natural connection between robustness and error correcting codes, which may be of independent interest. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 HARDNESS REDUCTIONS BETWEEN ROBUST CLASSIFIERS AND DETECTORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            733,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we prove our main result: a reduction between robust detectors and robust classifiers, and vice-versa. We first introduce some useful notation and define the (robust) risk of classifiers with and without a detection option. ",
+        "bbox": [
+            176,
+            809,
+            823,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            326,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a classification task with a distribution $\\mathcal { D }$ over examples $x \\in \\mathbb { R } ^ { d }$ with labels $y \\in$ $[ C ]$ . A classifier is a function $f : \\mathbb { R } ^ { d }  [ C ]$ . A detector is a classifier with an extra “rejection” ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "or ”detection” option $\\perp$ , that indicates the absence of a classification. We assume for simplicity that classifiers and detectors are deterministic. Our results can easily be extended to randomized functions as well. The binary indicator function $\\mathbb { 1 } _ { \\{ A \\} }$ is 1 if and only if the predicate $A$ is true. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first define a classifier’s risk, i.e., its classification error on unperturbed samples. ",
+        "bbox": [
+            173,
+            152,
+            723,
+            167
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Risk). Let $f : \\mathbb { R } ^ { d }  [ C ] \\cup \\{ \\bot \\}$ be a classifier (optionally with a detection output $\\perp$ ). The risk of $f$ is the expected rate at which $f$ fails to correctly classify a sample: ",
+        "bbox": [
+            173,
+            171,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44c657694cd74a56c1870443ece67a7d806cd61222c843330a77a072ca61eca5.jpg",
+        "text": "$$\nR ( f ) : = \\operatorname* { \\mathbb { E } } _ { ( x , y ) \\sim \\mathcal { D } } \\left[ \\mathbb { 1 } _ { \\{ f ( x ) \\neq y \\} } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            207,
+            596,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that for a detector, rejecting an unperturbed example sampled from the distribution $\\mathcal { D }$ is counted as an error. ",
+        "bbox": [
+            176,
+            248,
+            826,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For classifiers without a rejection option, we define the robust risk as the risk on worst-case adversarial examples (Madry et al., 2018). Given an input $x$ sampled from $\\mathcal { D }$ , an adversarial example $\\hat { x }$ is constrained to being within distance $d ( x , { \\hat { x } } ) \\leq { \\bar { \\epsilon } }$ from $x$ , where $d$ is some distance measure. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (Robust risk). Let $f : \\mathbb { R } ^ { d }  [ C ]$ be a classifier. The robust risk at distance $\\epsilon$ is: ",
+        "bbox": [
+            173,
+            330,
+            779,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf3313c2eebf9b088d68940d3fcdf78503af5aea78a5151d35b998f8ac2a42af.jpg",
+        "text": "$$\nR _ { a d \\nu } ^ { \\epsilon } ( f ) : = \\operatorname* { \\mathbb { E } } _ { ( x , y ) \\sim \\mathcal { D } } \\left[ \\operatorname* { m a x } _ { d ( x , \\hat { x } ) \\leq \\epsilon } \\mathbb { 1 } _ { \\{ f ( \\hat { x } ) \\neq y \\} } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            353,
+            633,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Thus, a sample $( x , y )$ is robustly classified if and only if every point within distance $\\epsilon$ of $x$ (including $x$ itself) is correctly classified as $y$ . ",
+        "bbox": [
+            171,
+            404,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a detector (a classifier with an extra detection/rejection output), we analogously define the robust risk with detection. The classifier is now allowed to reject adversarial examples. ",
+        "bbox": [
+            173,
+            439,
+            823,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 3 (Robust risk with detection). Let $f : \\mathbb { R } ^ { d }  [ C ] \\cup \\{ \\bot \\}$ be a classifier with an extra detection output $\\perp$ . The robust risk with detection at distance $\\epsilon$ is: ",
+        "bbox": [
+            173,
+            470,
+            821,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/280c3197d6ce35502a31b2d1bc26122b4c360c6fa70eabe111b6e26a291e0bec.jpg",
+        "text": "$$\nR _ { a d \\nu - d e t } ^ { \\epsilon } ( f ) : = \\underset { ( x , y ) \\sim \\mathcal { D } } { \\mathbb { E } } \\left[ \\operatorname* { m a x } _ { d ( x , \\hat { x } ) \\leq \\epsilon } \\mathbb { 1 } _ { \\left\\{ f ( x ) \\neq y \\vee f ( \\hat { x } ) \\notin \\left\\{ y , \\perp \\right\\} \\right\\} } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            508,
+            678,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "That is, a detector defense $f$ is robust on a natural input $x$ if and only if the defense classifies the natural input $x$ correctly, and the defense either rejects or correctly classifies every perturbed input $\\hat { x }$ within distance $\\epsilon$ from $x$ . The requirement that the defense correctly classify natural examples eliminates pathological defenses that reject all inputs. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ROBUST DETECTION IMPLIES INEFFICIENT ROBUST CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            694,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We are now ready to introduce our main result, a reduction from a robust detector for adversarial examples at distance $\\epsilon$ , to an inefficient robust classifier at distance $\\epsilon / 2$ . We later prove that this reduction also holds in the reverse direction, thereby demonstrating the equivalence between robust detection and classification—up to computational hardness. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4 $\\epsilon$ -robust detection implies inefficient $\\epsilon / 2$ -robust classification). Let $d ( \\cdot , \\cdot )$ be an arbitrary metric. Let $f$ be a detector that achieves risk $R ( f ) = \\alpha _ { \\mathrm { {  } } }$ , and robust risk with detection $R _ { a d \\nu - d e t } ^ { \\epsilon } ( f ) = \\beta$ . Then, we can construct an explicit (but inefficient) classifier $g$ that achieves risk $R ( g ) \\leq \\alpha$ and robust risk $R _ { a d \\nu } ^ { \\epsilon / 2 } ( g ) \\le \\beta$ . ",
+        "bbox": [
+            173,
+            718,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The classifier $g$ is constructed as follows on input $x$ : ",
+        "bbox": [
+            174,
+            785,
+            517,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Run the detector model $y  f ( x )$ . If the input is not rejected, i.e., $y \\ne \\perp$ , then output the label y that was predicted by the detector. ",
+        "bbox": [
+            178,
+            804,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Otherwise, find an input $x ^ { \\prime }$ within distance $\\epsilon / 2$ of $x$ that is not rejected, i.e., $d ( x , x ^ { \\prime } ) \\leq \\epsilon / 2$ and $f ( x ^ { \\prime } ) \\neq \\bot$ . If such an input $x ^ { \\prime }$ exists, output the label $y \\gets f ( x ^ { \\prime } )$ . Else, output a uniformly random label $y \\in [ C ]$ . ",
+        "bbox": [
+            179,
+            839,
+            825,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An intuitive illustration for our construction, and for the proof of the theorem (see below) is in Figure 1. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1703fa013d6a1ee6b00378a016c2a93fc0e3073c9d6734ac06a5bcc5e5e8f741.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the construction of a robust classifier from a robust detector in Theorem 4. The outer blue circle represents all inputs at distance at most $\\epsilon$ from the input $x$ . For a detector $f$ , the areas in green correspond to correctly classified inputs, and ratcheted gray areas correspond to rejected inputs. The detector $f$ is thus robust on $x$ up to distance $\\epsilon$ . The classifier $g$ classifies a perturbed input $\\hat { x }$ , at distance $\\epsilon / 2$ from $x$ , by finding any input within distance $\\epsilon / 2$ from $\\hat { x }$ (the red dashed circle) that is not rejected by $f$ . Such an input necessarily exists and is correctly labeled by $f$ . The classifier $g$ is thus robust on $x$ up to distance $\\epsilon / 2$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            349,
+            99,
+            647,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our construction can be viewed as an analog of minimum distance decoding in coding theory. We can view a clean data point sampled from $\\mathcal { D }$ as a codeword, and an adversarial example $\\hat { x }$ as a noisy message with a certain number of errors (where the error magnitude is measured using an arbitrary metric on $\\mathbb { R } ^ { d }$ rather than the Hamming distance that is typically used for error correcting codes). A standard result in coding theory states that if a code can detect $\\alpha$ errors, then it can correct $\\alpha / 2$ errors. This result follows from a “ball-packing” argument: if $\\alpha$ errors can be detected, then any two valid codewords must be at least at distance $\\alpha$ from each other, and therefore $\\alpha / 2$ errors can be corrected via minimum distance decoding. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 4. First, note that the natural accuracy of our constructed classifier $g$ is at least as high as that of the detector $f$ , since $g$ always mimics the output of $f$ whenever $f$ does not reject an input sampled from $\\mathcal { D }$ . Thus, $R ( g ) \\dot { \\leq } R ( f ) = \\alpha$ . ",
+        "bbox": [
+            174,
+            597,
+            825,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Now, for the sake of contradiction, consider an input $( x , y ) \\sim \\mathcal { D }$ for which the constructed classifier $g$ is not robust at distance $\\epsilon / 2$ . By construction, this means that there exists some input $\\hat { x }$ at distance $\\epsilon / 2$ from $x$ such that $\\hat { x }$ is misclassified, i.e., $g ( \\hat { x } ) = \\hat { y } \\neq y$ . We will show that the detector $f$ is not robust with detection for $x$ either (for attacks at distance up to $\\epsilon$ ). ",
+        "bbox": [
+            173,
+            646,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By definition of the classifier $g$ , if $g ( \\hat { x } ) = \\hat { y } \\neq y$ then either: ",
+        "bbox": [
+            173,
+            709,
+            568,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• The detector $f$ also misclassifies $\\hat { x }$ , i.e., $f ( \\hat { x } ) = \\hat { y }$ . So $f$ is not robust with detection for $x$ at distance $\\epsilon$ .   \n• There exists an input $x ^ { \\prime }$ within distance $\\epsilon / 2$ of $x$ , such that the detector $f$ misclassifies $x ^ { \\prime }$ , i.e. $\\boldsymbol { f } ( \\boldsymbol { x } ^ { \\prime } ) = \\boldsymbol { \\hat { y } }$ . Note that by the triangular inequality, $d ( x , x ^ { \\prime } ) \\leq d ( x , \\hat { x } ) + d ( \\hat { x } , x ^ { \\prime } ) \\leq \\epsilon / 2 + \\epsilon / 2 = \\epsilon ,$ and thus $f$ is not robust with detection for $x$ at distance $\\epsilon$ .   \n• The detector $f$ rejects all inputs $x ^ { \\prime }$ within distance $\\epsilon / 2$ of $x$ (and thus $g$ has output $\\hat { y }$ by sampling a label at random). Since $d ( x , { \\hat { x } } ) \\leq \\epsilon / 2$ , this implies that the detector also rejects the clean input $x$ , i.e., $f ( x ) = \\bot$ , and thus $f$ is not robust with detection for $x$ . ",
+        "bbox": [
+            217,
+            739,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In summary, whenever the constructed classifier $g$ fails to robustly classify an input $x$ up to distance $\\epsilon / 2$ , the detector $f$ also fails to robustly classify $x$ with detection up to distance $\\epsilon$ . Taking expectations over the entire distribution $\\mathcal { D }$ concludes the proof. □ ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the classifier $g$ constructed in Theorem 4 is computationally inefficient. Indeed, the second step of the defense consists in finding a non-rejected input within some metric ball. If the original detector $f$ is a non-convex function (e.g., a deep neural network), then this step consists in solving an intractable non-convex optimization problem. Our reduction is thus typically not suitable for building a practical robust classifier. Instead, it demonstrates the existence of an inefficient but explicit robust classifier. We discuss the implications of this result more thoroughly in Section 3. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A corollary to our reduction is that many “information theoretic” results about robust classifiers can   \nbe directly extended to robust detectors. For example, Tsipras et al. (2019) prove that there exists a   \nformal tradeoff between a classifier’s clean accuracy and robust accuracy for certain natural tasks.   \nSince their result applies to any classifier (including inefficient ones), combining their result with our   \nreduction implies that a similar accuracy-robustness tradeoff exists for detectors. More precisely,   \nTsipras et al. (2019) show that for certain classification tasks and suitable choices of parameters   \n$\\alpha , \\beta , \\epsilon$ , any classifier $g$ which achieves risk $R ( g ) \\leq \\alpha$ must have robust risk at least $R _ { \\mathrm { a d v } } ^ { \\bar { \\epsilon } } ( g ) \\geq \\beta$ inst k at $\\ell _ { \\infty }$ -t s boumust d by o hav $\\epsilon$ . By our reduction, this implies t robust risk with detection at least $f$ withainst $R ( f ) \\leq \\alpha$ $R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon / 2 } ( f ) \\geq \\beta$   \n$\\ell _ { \\infty }$ $\\epsilon / 2$ ",
+        "bbox": [
+            173,
+            253,
+            825,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar arguments can be applied to show, for instance, that the increased data complexity of robust generalization from Schmidt et al. (2018), or the tradeoff between robustness to multiple perturbation types from Tramer & Boneh (2019), also apply to robust detectors. \\` ",
+        "bbox": [
+            176,
+            402,
+            821,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our reduction does not apply for “computational” hardness results that have been shown for robust classification. For example, Garg et al. (2020) and Bubeck et al. (2018) show (“unnatural”) distributions where learning a robust classifier is computationally hard—under standard cryptographic assumptions. We cannot use Theorem 4 to conclude that learning a robust detector is hard for these distributions, since the existence of such a detector would only imply an inefficient robust classifier which does not contradict the results of Garg et al. (2020) or Bubeck et al. (2018). ",
+        "bbox": [
+            174,
+            452,
+            825,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 ROBUST CLASSIFICATION IMPLIES INEFFICIENT ROBUST DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            694,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A similar argument as in Theorem 4 can be used in the opposite direction, to show that a robust classifier at distance $\\epsilon / 2$ implies an inefficient robust detector at distance $\\epsilon$ . Taken together, Theorem 4 and Theorem 5 show that robust detection and classification are equivalent, up to a factor 2 in the norm bound and up to computational constraints. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5 $( \\epsilon / 2$ robust-classification implies inefficient $\\epsilon$ -robust detection). Let $d ( \\cdot , \\cdot )$ be an arbi  \ntrary metric. Let g be a defense than explicit (but inefficient) defense achieves robust rithat achieves risk $R _ { a d \\nu } ^ { \\epsilon / 2 } ( f ) = \\beta$ . Then, we can constructrobust risk with detection $f$ $R ( f ) \\le \\beta$   \n$R _ { a d \\nu - d e t } ^ { \\epsilon } ( f ) \\leq \\beta$ . ",
+        "bbox": [
+            176,
+            638,
+            825,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The defense $f$ is constructed as follows on input $x$ : ",
+        "bbox": [
+            174,
+            705,
+            509,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Run the classifier $y  g ( x )$ . ",
+        "bbox": [
+            218,
+            732,
+            419,
+            748
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Find a perturbed input $x ^ { \\prime }$ withing distance $\\epsilon / 2$ of $x$ that is classified differently, i.e., $d ( x , x ^ { \\prime } ) \\leq \\epsilon / 2$ and $g ( x ^ { \\prime } ) \\neq y$ . If such an input $x ^ { \\prime }$ exists, reject the input and output ⊥. Else, output the class $y$ . ",
+        "bbox": [
+            218,
+            756,
+            823,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We provide the proof of Theorem 5 in Appendix A. ",
+        "bbox": [
+            174,
+            810,
+            511,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A main distinction between Theorem 4 and Theorem 5 is that the construction in Theorem 4 preserves clean accuracy, but the construction in Theorem 5 does not. That is, the constructed robust detector in Theorem 5 has clean accuracy that is equal to the robust classifier’s robust accuracy. ",
+        "bbox": [
+            176,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The construction in Theorem 5 can be efficiently (but approximately) instantiated by a certifiably robust classifier (Wong & Kolter, 2018; Raghunathan et al., 2018). These defenses can certify that a classifier’s output is constant for all points within some distance $\\epsilon$ of the input. For an adversarial example $\\hat { x }$ for $g$ , the certification always fails and thus the constructed detector $f$ will reject $\\hat { x }$ . If $g$ is robust and the certification succeeds, the detector $f$ copies the output of $g$ . However, a certified defense may fail to certify a robust input (a false negative), and thus the detector $f$ may reject more inputs than with the “optimal” construction in Theorem 5. This reduction from a certified classifier to a detector is implicit in (Wong & Kolter, 2018, Section 3.1). ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 WHAT ARE DETECTION DEFENSES CLAIMING? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            601,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now survey 14 detection defenses, and consider the robust classification performance that these defenses implicitly claim (via Theorem 4). As we will see, in 12/14 cases, the defenses’ detection results imply an inefficient classifier with far better robust accuracy than the state-of-the-art. ",
+        "bbox": [
+            176,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Before presenting our experimental setup and the explicit results from the reduction, we first discuss how we believe these results should be interpreted. ",
+        "bbox": [
+            173,
+            277,
+            821,
+            305
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interpreting our reduction. Suppose that some detector defense claims a robust accuracy that implies—via our reduction—an inefficient classifier with much higher robustness that the state-ofthe-art (e.g., the defense A described in the introduction of this paper). ",
+        "bbox": [
+            174,
+            323,
+            825,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A first possible interpretation of our reduction is that this robust detector implies the existence of a robust classifier. This interpretation is rather weak however, since it is typically presumed that robust classification is possible, and that human perception is one concrete example of a robust classifier. The mere existence of a robust classifier is thus typically already assumed to be true. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our reduction yields a stronger result. It provides an explicit construction of an (inefficient) robust classifier from a robust detector. The question then is whether we should expect the construction of inefficient robust classifiers to be easier than the construction of efficient ones. That is, do we expect that we can leverage computational inefficiency to build more robust classifiers that the current state-of-the-art? ",
+        "bbox": [
+            174,
+            434,
+            825,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We do not know of a positive answer to this question, and there is evidence to suggest that the answer may be negative.1 For example, the work of Schmidt et al. (2018) proves that for a synthetic classification task between Gaussian distributions, building more robust classifiers requires additional data regardless of the amount of computation power. Their results are corroborated by current state-ofthe-art robust classifiers based on adversarial training (Madry et al., 2018), which do not appear to be limited by computational constraints. On CIFAR-10 for example, adversarial training achieves $100 \\%$ robust training accuracy (Schmidt et al., 2018). Thus, it is unclear how computational inefficiency could be leveraged to build more robust classifiers using existing techniques. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Candidate approaches could be to train much larger models (e.g., with an exponential number of parameters), or to perform an exhaustive architecture search to find more robust models. Yet, note that the robust classifier constructed in our reduction only uses its unbounded computational power at inference time. That is, the classifier that is built in Theorem 4 uses a trained detector model as a subroutine (which is presumed to be efficient), and then solves a non-convex optimization problem at inference time. The classifier built in our reduction is thus presumably weaker than a robust classifier that can be trained with unbounded computational power. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To summarize, when a detector defense claims a certain robust accuracy, this implies the existence of a concretely instantiatable robust classifier with an inefficient inference procedure. If this inefficient classifier is much more robust than the current state-of-the-art, this does not necessarily mean that the defense’s claims is wrong. But given how challenging robust classification is proving to be, we have reason to be skeptical of such a major breakthrough (even for inefficient classifiers). To compound this, many proposed detection defenses are quite simple, and reject adversarial inputs based on some standard statistical test over a neural network’s features. It would thus be particularly surprising if such simple techniques could yield robust classifiers, given that “simple” approaches to adversarial robustness (denoising, compression, randomness, etc.) are ineffective (He et al., 2017). ",
+        "bbox": [
+            174,
+            733,
+            825,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a result, it is not too surprising that a number of the detector defenses that we survey have already been broken by stronger attacks (Carlini & Wagner, 2017; Tramer et al., 2020). Our reduction would \\` have already suggested that such a break was likely to happen. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. We choose 14 detector defenses from the literature (see Table 1). Our selection of these defenses was partially motivated by a pragmatic consideration on the easiness of translating the defenses’ claims into a bound on the robust risk with detection $R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon }$ . Indeed, some defenses simply report a single AUC score for the detector’s performance, from which we cannot derive a useful bound on the robust risk. We thus focus on defenses that either directly report a robust error akin to Definition 3, or that provide concrete pairs of false-positive and false-negative rates (e.g., a full ROC curve). In the latter case, we compute a “best-effort” bound on the robust risk with detection2 as: ",
+        "bbox": [
+            173,
+            161,
+            825,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e622d645b3f35c117ff52694ec9773f02e8ea8238d5cfacd531d2db3bd601ae.jpg",
+        "text": "$$\nR _ { \\mathrm { a d v - d e t } } ^ { \\epsilon } ( f ) \\leq \\mathrm { F P R } + \\mathrm { F N R } + R ( f ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            272,
+            617,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where FPR and FNR are the detector’s false-positive and false-negative rates for a fixed detection threshold, and $R ( f )$ is the defense’s standard risk (i.e., the test error on natural examples). ",
+        "bbox": [
+            171,
+            301,
+            821,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The above union bound in Equation (4) is quite pessimistic, as we may over-count examples that lead to multiple sources of errors (e.g., a natural input that is misclassified and erroneously detected). The true robustness claim made by these detector defenses might thus be stronger than what we obtain from our bound. We encourage future detection papers to report their adversarial risk with detection, $R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon }$ , to facilitate direct comparisons with robust classifiers using our reduction. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The 14 detector defenses use three datasets: MNIST, CIFAR-10 and ImageNet, and consider adversarial examples under the $\\ell _ { \\infty }$ or $\\ell _ { 2 }$ norms. Given a claim of robust detection at distance \u000f, we contrast it to a state-of-the-art robust classification result for distance $\\epsilon / 2$ : ",
+        "bbox": [
+            176,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• On MNIST with $\\ell _ { \\infty }$ attacks, we use the adversarially-trained TRADES classifier (Zhang et al., 2019) and measure robust error with the Square attack (Andriushchenko et al., 2020).   \n• On MNIST with $\\ell _ { 2 }$ attacks, we use the adversarially-trained classifier from Tramer & \\` Boneh (2019) and measure robust error with PGD (Madry et al., 2018).   \n• On CIFAR-10, for both $\\ell _ { \\infty }$ and $\\ell _ { 2 }$ attacks we use the adversarially-trained classifier of Rebuffi et al. (2021) (trained without external data), and attack it using the APGD-CE attack from AutoAttack (Croce & Hein, 2020).   \n• For ImageNet, for both $\\ell _ { \\infty }$ and $\\ell _ { 2 }$ attacks we use adversarially-trained classifiers and PGD attacks from Engstrom et al. (2019). ",
+        "bbox": [
+            217,
+            468,
+            825,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also consider two certified defenses for $\\ell _ { \\infty }$ attacks on CIFAR-10: the robust classifier of Zhang et al. (2020a), and a recent certified detector of Sheikholeslami et al. (2021). ",
+        "bbox": [
+            174,
+            626,
+            823,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results. As we can see from Table 1, most defenses claim a detection performance that implies a far greater robust accuracy than our current best robust classifiers. To illustrate with a concrete example, the CIFAR-10 detector of Miller et al. (2019) claims to achieve robust accuracy with detection of $7 5 \\%$ for $\\ell _ { 2 }$ attacks with $\\epsilon = 2 . 9$ . Using Theorem 4, this implies an inefficient classifier with robust accuracy of $7 5 \\%$ for $\\ell _ { 2 }$ attacks with $\\epsilon = { } ^ { 2 . 9 } / 2 = 1 . 4 5$ . Yet, the current state-of-the-art robust accuracy for such a perturbation budget is only $3 0 \\%$ (Rebuffi et al., 2021). If this detector defense’s robustness claim were correct, it would imply a remarkable breakthrough in robust classification. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Why do many of these defenses claim robust accuracies that appear “too good to be true”? A primary reason is that the vast majority of the above detector defenses do not consider evaluations against adaptive attacks (Carlini et al., 2019; Athalye et al., 2018; Tramer et al., 2020). That is, \\` these defenses show that they can detect some fixed attacks, and thereafter conclude that the detector is robust against all attacks. As in the case of robust classifiers, such an evaluation is clearly insufficient! Some defenses do evaluate against adaptive adversaries, but fail to build a sufficiently strong attack to reliably approximate the worst-case robust risk. Because of the lack of a strong comparative baseline, it is not always immediately clear that these results are overly strong. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/35afe76e5c882d9d74a70d86ea496028c6c8d6414cd130e3ebb49471d266dd3d.jpg",
+        "table_caption": [
+            "Table 1: For each detector defense, we compute a (best-effort) bound on the claimed robust risk with detection $R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon }$ using Equation (4), and report the complement (the robust accuracy with detection), $1 - R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon }$ . For each detector’s robustness claim (at distance $\\epsilon$ ), we report the stateof-the-art robust classification accuracy for attacks at distance $\\epsilon / 2$ , denoted $1 - R _ { \\mathrm { a d v } } ^ { \\epsilon / 2 }$ . Detection defense claims that imply a higher robust classification accuracy than the current state-of-the-art are highlighted in red. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Defense</td><td>Norm</td><td>E</td><td>1-Radv-det</td><td>1- R</td></tr><tr><td rowspan=\"3\">MNIST</td><td>Grosse et al. (2017)</td><td>l8</td><td>0.5</td><td>≥ 98%</td><td>94%</td></tr><tr><td>Ma et al. (2018)</td><td>l2</td><td>4.2</td><td>≥ 99%</td><td>72%</td></tr><tr><td>Raghuram et al. (2021)</td><td>l2</td><td>8.9</td><td>≥ 74%</td><td>0%</td></tr><tr><td rowspan=\"8\">CIFAR-10</td><td>Yin et al. (2020)</td><td>l2</td><td>1.7</td><td>≥ 90%</td><td>66%</td></tr><tr><td>Feinman et al. (2017)</td><td>l2</td><td>2.7</td><td>≥ 43%</td><td>36%</td></tr><tr><td>Miller et al. (2019)</td><td>l2</td><td>2.9</td><td>≥ 75%</td><td>30%</td></tr><tr><td>Raghuram et al. (2021)</td><td>l</td><td>4.0</td><td>≥ 56%</td><td>10%</td></tr><tr><td>Ma &amp; Liu (2019)</td><td>l8</td><td>4/255</td><td>≥ 96%</td><td>85%</td></tr><tr><td>Roth et al. (2019)</td><td>l8</td><td>8/255</td><td>≥ 66%</td><td>79%</td></tr><tr><td>Lee et al. (2018)</td><td>lo</td><td>20/255</td><td>≥ 81%</td><td>59%</td></tr><tr><td>Li et al. (2019)</td><td>lo</td><td>26/255</td><td>≥ 80%</td><td>44%</td></tr><tr><td rowspan=\"5\">ImageNet</td><td>Xu et al. (2018)</td><td>l</td><td>1.0</td><td>≥ 67%</td><td>54%</td></tr><tr><td>Ma &amp; Liu (2019)</td><td>l8</td><td>2/255</td><td>≥ 68%</td><td>55%</td></tr><tr><td>Jha et al. (2019)</td><td>lo</td><td>2/255</td><td>≥ 30%</td><td>55%</td></tr><tr><td>Hendrycks &amp; Gimpel (2017)</td><td>l8</td><td>10/255</td><td>≥ 76%</td><td>30%</td></tr><tr><td>Yu et al. (2019)</td><td>l8</td><td>26/255</td><td>M 7%</td><td>5%</td></tr></table>",
+        "bbox": [
+            194,
+            212,
+            797,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For example, the recent work of Raghuram et al. (2021, ICML Long Talk) builds a detector on MNIST with a FNR of $\\leq 5 \\%$ at a FPR of $\\leq 2 0 \\%$ , for adaptive $\\ell _ { 2 }$ attacks bounded by $\\epsilon = 8 . 9$ . Yet, this perturbation bound is much larger than the average distance between an MNIST image and the nearest image from a different class! Thus, an attack within this perturbation bound can trivially reduce the detector’s accuracy to chance. On CIFAR-10, the same detector achieves $9 5 \\%$ clean accuracy, and a FNR of $\\leq 1 9 \\%$ at a FPR of $\\leq 2 0 \\%$ for adaptive $\\ell _ { 2 }$ attacks bounded by $\\epsilon = 4$ . Using Equation (4), this yields a bound on the robust accuracy with detection of $1 - R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon } ( f ) \\geq$ $1 - \\bar { ( 5 \\% + 1 9 \\% + 2 0 \\% ) } = 5 6 \\%$ . In contrast, the best robust classifier we are aware of for $\\ell _ { 2 }$ attacks bounded by $\\epsilon = 2$ achieves robust accuracy of only $1 0 \\%$ (Rebuffi et al., 2021). In summary, the adaptive attack considered in this detector defense’s evaluation is highly unlikely to be good approximation of a worst-case attack, and this defense can likely be broken by stronger attacks. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            720
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Certifiably robust detection and classification. In Table 2, we look at the robust accuracy with detection, and standard robust accuracy achieved by certified defenses (for which the claimed robustness numbers are necessarily mathematically correct). ",
+        "bbox": [
+            176,
+            742,
+            823,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We note that our reduction is not as meaningful in the case of certified defenses, since it is highly plausible that computational inefficiency can be leveraged to build better certified classifiers. Indeed, given any robust classifier (e.g., an adversarially trained model), the classifier’s robustness can always be certified inefficiently (by enumerating over all points within an $\\epsilon$ -ball). Thus, the existence of an inefficient classifier with higher certified robustness than the state-of-the-art is to be expected. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, we find that existing results for certified classifiers and detectors perfectly match what is implied by our reduction (up to $\\pm 2 \\%$ error). For example, Zhang et al. (2020a) follow a long line of results on robust classifiers and achieve $3 9 \\%$ robust accuracy on CIFAR-10 for perturbations of $\\ell _ { \\infty }$ -norm below $^ { 4 } / 2 5 5$ . Together with Theorem 5, this implies an inefficient detector with $3 9 \\%$ robust detection accuracy for perturbations of $\\ell _ { \\infty }$ -norm below $^ { 8 } / 2 5 5$ . The recent work of Sheikholeslami et al. (2021) nearly matches that bound $3 7 \\%$ robust accuracy with detection), with a defense that has the advantage of being concretely efficient. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/308cd424cf793a3ba0100fdea38ed9dfb95bea708f1ec26aa902357976d5420b.jpg",
+        "table_caption": [
+            "Table 2: Certified robust accuracy $1 - R _ { \\mathrm { a d v } } ^ { \\epsilon / 2 }$ for the defense of Zhang et al. (2020a), and certified robust accuracy with detection $1 - R _ { \\mathrm { a d v - d e t } } ^ { \\epsilon }$ dv for the defense of Sheikholeslami et al. (2021). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>E</td><td>1-Radv-det</td><td></td></tr><tr><td>8/255</td><td>37%</td><td>39%</td></tr><tr><td>16/255</td><td>32%</td><td>33%</td></tr></table>",
+        "bbox": [
+            380,
+            156,
+            612,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            243,
+            826,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "These results give additional credence to our thesis: with current techniques, robust classification is indeed approximately twice as hard (in terms of the perturbation bounds covered) than robust detection. ",
+        "bbox": [
+            176,
+            292,
+            823,
+            334
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Extensions and open problems. The main open problem raised by our work is of course whether it could be possible to show an efficient reduction between classification and detection of adversarial examples, but this seems implausible (at least with our minimum distance decoding approach). ",
+        "bbox": [
+            174,
+            349,
+            825,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another interesting question is whether a similar reduction can be shown for robustness to less “structured” perturbations than $\\ell _ { p }$ balls and other metric spaces. For example, there has been a line of research on defending against adversarial patches (Brown et al., 2017), using empirical (Hayes, 2018; Naseer et al., 2019; Chou et al., 2020) and certifiable techniques (Chiang et al., 2020; Zhang et al., 2020b; Xiang et al., 2021). To use our result, we would have to define some metric to measure the size of an adversarial patch’s perturbation. Yet, the size of a patch is typically defined by the number of contiguously perturbed pixels, which does not define a metric (in particular, it does not satisfy the triangular inequality which our reduction relies on). ",
+        "bbox": [
+            174,
+            397,
+            825,
+            510
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, similar hardness reductions might exist between other candidate approaches for building robust classifiers. For example, the question of whether (test-time) randomness can be leveraged to build more robust models is also intriguing .Empirical defenses that use randomness can be notoriously hard to evaluate (Athalye et al., 2018; Tramer et al., 2020), so a reduction similar to ours \\` might be useful in showing that we should not expect such approaches to bare fruit. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            587
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            318,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have shown formal reductions between robust classification with, and without, a detection option. Our results show that significant progress on one of these two tasks implies similar progress on the other—unless computational inefficiency can somehow be leveraged to build more robust models. This raises the question on whether we should spend our efforts on studying both of these tasks, or focus our efforts on a single one. ",
+        "bbox": [
+            174,
+            637,
+            823,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On one hand, the two tasks represent different ways of tackling a common goal, and working on either task might result in new techniques or ideas that apply to the other task as well. On the other hand, our reductions show that unless we make progress on both tasks, work on one of the tasks can merely aim to match the robustness of our inefficient constructions, whilst improving their computational complexity. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We believe our reduction will serve as a useful sanity-check when assessing the claims of future detector defenses. Detector defenses’ robustness evaluations have received less stringent scrutiny than robust classifiers over the past years, perhaps in part due to a lack of strong comparative baselines. Instead of having to wait until some detector defense’s claims pass the test-of-time, we show that detection results can be directly contrasted against long-standing results for robust classification. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When applying this approach to past detector defenses, we find that many make robustness claims that imply significant breakthroughs in robust classification. We believe our reduction could have been useful in highlighting the suspiciously strong claims made by many of these defenses—before they were explicitly broken by stronger attacks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ethics statement. Our paper demonstrates a fundamental barrier towards detecting against adversarial examples, under the assumption that our current techniques are insufficient to achieve strong (inefficient) robust classification. We do not however explicitly break any existing defenses (our results merely strongly suggest that many existing detector defenses’ claims are suspiciously high). Our paper therefore cannot lead to any explicit harms, but aims to further our understanding of the hardness of robust classification and detection. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reproducibility statement. Our paper’s contribution is mainly of theoretical nature. Section 2 is self-contained and clearly states our assumptions, results and proofs (except for the proof of Theorem 5 in Appendix A). The experiments in Section 3 use only public datasets and pre-trained models, with clearly indicates hyper-parameters for all attacks that we evaluate. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            285,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maksym Andriushchenko, Francesco Croce, Nicolas Flammarion, and Matthias Hein. Square attack: a query-efficient black-box adversarial attack via random search. In European Conference on Computer Vision, 2020. ",
+        "bbox": [
+            173,
+            304,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            174,
+            354,
+            821,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387–402. Springer, 2013. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            464
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. arXiv preprint arXiv:1712.09665, 2017. ",
+        "bbox": [
+            173,
+            473,
+            821,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastien Bubeck, Yin Tat Lee, Eric Price, and Ilya Razenshteyn. Adversarial examples from cryp-´ tographic pseudo-random generators. arXiv preprint arXiv:1811.06418, 2018. ",
+        "bbox": [
+            173,
+            511,
+            820,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In AISec, pp. 3–14. ACM, 2017. ",
+        "bbox": [
+            173,
+            549,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, and Aleksander Madry. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019. ",
+        "bbox": [
+            176,
+            587,
+            823,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ping-yeh Chiang, Renkun Ni, Ahmed Abdelkader, Chen Zhu, Christoph Studer, and Tom Goldstein. Certified defenses for adversarial patches. arXiv preprint arXiv:2003.06693, 2020. ",
+        "bbox": [
+            171,
+            638,
+            821,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edward Chou, Florian Tramer, and Giancarlo Pellegrino. Sentinet: Detecting physical attacks \\` against deep learning systems. In Workshop on Deep Learning Security, 2020. ",
+        "bbox": [
+            171,
+            676,
+            821,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020. ",
+        "bbox": [
+            169,
+            715,
+            825,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Francesco Croce, Maksym Andriushchenko, Vikash Sehwag, Nicolas Flammarion, Mung Chiang, Prateek Mittal, and Matthias Hein. Robustbench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670, 2020. ",
+        "bbox": [
+            176,
+            752,
+            823,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Andrew Ilyas, Hadi Salman, Shibani Santurkar, and Dimitris Tsipras. Robustness (python library), 2019. URL https://github.com/MadryLab/robustness. ",
+        "bbox": [
+            169,
+            805,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reuben Feinman, Ryan R Curtin, Saurabh Shintre, and Andrew B Gardner. Detecting adversarial samples from artifacts. arXiv preprint arXiv:1703.00410, 2017. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanjam Garg, Somesh Jha, Saeed Mahloujifar, and Mahmoody Mohammad. Adversarially robust learning could leverage computational hardness. In Algorithmic Learning Theory, pp. 364–385. PMLR, 2020. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kathrin Grosse, Praveen Manoharan, Nicolas Papernot, Michael Backes, and Patrick McDaniel. On the (statistical) detection of adversarial examples. arXiv preprint arXiv:1702.06280, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jamie Hayes. On visible adversarial perturbations & digital watermarking. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1597–1604, 2018. ",
+        "bbox": [
+            171,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. In USENIX Workshop on Offensive Technologies, 2017. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. Early methods for detecting adversarial images. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            232,
+            821,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Susmit Jha, Sunny Raj, Steven Lawrence Fernandes, Sumit Kumar Jha, Somesh Jha, Gunjan Verma, Brian Jalaian, and Ananthram Swami. Attribution-driven causal analysis for detection of adversarial examples. arXiv preprint arXiv:1903.05821, 2019. ",
+        "bbox": [
+            173,
+            271,
+            823,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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, 2018. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yingzhen Li, John Bradshaw, and Yash Sharma. Are generative classifiers more robust to adversarial attacks? In International Conference on Machine Learning, pp. 3804–3814. PMLR, 2019. ",
+        "bbox": [
+            173,
+            375,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shiqing Ma and Yingqi Liu. Nic: Detecting adversarial samples with neural network invariant checking. In Proceedings of the 26th Network and Distributed System Security Symposium (NDSS 2019), 2019. ",
+        "bbox": [
+            174,
+            414,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xingjun Ma, Bo Li, Yisen Wang, Sarah M Erfani, Sudanthi Wijewickrema, Grant Schoenebeck, Dawn Song, Michael E Houle, and James Bailey. Characterizing adversarial subspaces using local intrinsic dimensionality. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            176,
+            465,
+            823,
+            510
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            517,
+            823,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Miller, Yujia Wang, and George Kesidis. When not to classify: Anomaly detection of attacks (ada) on dnn classifiers at test time. Neural computation, 31(8):1624–1670, 2019. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muzammal Naseer, Salman Khan, and Fatih Porikli. Local gradients smoothing: Defense against localized adversarial attacks. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 1300–1307. IEEE, 2019. ",
+        "bbox": [
+            173,
+            608,
+            826,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianyu Pang, Huishuai Zhang, Di He, Yinpeng Dong, Hang Su, Wei Chen, Jun Zhu, and Tie-Yan Liu. Adversarial training with rectified rejection. arXiv preprint arXiv:2105.14785, 2021. ",
+        "bbox": [
+            174,
+            661,
+            823,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jayaram Raghuram, Varun Chandrasekaran, Somesh Jha, and Suman Banerjee. A general framework for detecting anomalous inputs to dnn classifiers. In International Conference on Machine Learning, 2021. ",
+        "bbox": [
+            173,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Sven Gowal, Dan A Calian, Florian Stimberg, Olivia Wiles, and Timothy Mann. Fixing data augmentation to improve adversarial robustness. arXiv preprint arXiv:2103.01946, 2021. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Roth, Yannic Kilcher, and Thomas Hofmann. The odds are odd: A statistical test for detecting adversarial examples. In International Conference on Machine Learning, 2019. ",
+        "bbox": [
+            169,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. In Advances In Neural Information Processing Systems, pp. 5019–5031, 2018. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fatemeh Sheikholeslami, Ali Lotfi, and J Zico Kolter. Provably robust classification of adversarial examples with detection. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. In \\` Advances In Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Nicholas Carlini, Wieland Brendel, and Aleksander Madry. On adaptive attacks to \\` adversarial example defenses. In Conference on Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In International Conference on Machine Learning, pp. 5283–5292, 2018. ",
+        "bbox": [
+            173,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chong Xiang, Arjun Nitin Bhagoji, Vikash Sehwag, and Prateek Mittal. Patchguard: A provably robust defense against adversarial patches via small receptive fields and masking. In 30th {USENIX} Security Symposium ({USENIX} Security 21), 2021. ",
+        "bbox": [
+            173,
+            356,
+            825,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. In Network and Distributed System Security Symposium, 2018. ",
+        "bbox": [
+            173,
+            409,
+            821,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xuwang Yin, Soheil Kolouri, and Gustavo K Rohde. Gat: Generative adversarial training for adversarial example detection and robust classification. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tao Yu, Shengyuan Hu, Chuan Guo, Wei-Lun Chao, and Kilian Q Weinberger. A new defense against adversarial images: Turning a weakness into a strength. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P. Xing, Laurent El Ghaoui, and Michael I. Jordan. Theoretically principled trade-off between robustness and accuracy. In International Conference on Machine Learning, 2019. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. In International Conference on Learning Representations, 2020a. ",
+        "bbox": [
+            173,
+            601,
+            821,
+            643
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhanyuan Zhang, Benson Yuan, Michael McCoyd, and David Wagner. Clipped bagnet: Defending against sticker attacks with clipped bag-of-features. In 2020 IEEE Security and Privacy Workshops (SPW), pp. 55–61. IEEE, 2020b. ",
+        "bbox": [
+            176,
+            652,
+            823,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A PROOF OF THEOREM 5. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            406,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We recall Theorem 5: ",
+        "bbox": [
+            174,
+            133,
+            318,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5 $( \\epsilon / 2$ robust-classification implies inefficient $\\epsilon$ -robust detection). Let $d ( \\cdot , \\cdot )$ be an arbi  \ntrary metric. Let g be a defense than explicit (but inefficient) defense achieves robust rithat achieves risk $R _ { a d \\nu } ^ { \\epsilon / 2 } ( f ) = \\beta$ . Then, we can constructrobust risk with detection $f$ $R ( f ) \\leq \\beta$   \n$R _ { a d \\nu - d e t } ^ { \\epsilon } ( f ) \\leq \\beta$ . ",
+        "bbox": [
+            173,
+            151,
+            825,
+            213
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The defense $f$ is constructed as follows on input $x$ : ",
+        "bbox": [
+            176,
+            218,
+            509,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Run the classifier $y  g ( x )$ . ",
+        "bbox": [
+            218,
+            244,
+            419,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Find a perturbed input $x ^ { \\prime }$ withing distance $\\epsilon / 2$ of $x$ that is classified differently, i.e., $\\bar { d } ( x , x ^ { \\prime } ) \\bar { \\ } \\leq \\ \\epsilon / 2$ and $g ( x ^ { \\prime } ) \\neq y$ . If such an input $x ^ { \\prime }$ exists, reject the input and output ⊥. Else, output the class $y$ . ",
+        "bbox": [
+            217,
+            268,
+            823,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 5. Note that for any input $( x , y )$ for which the classifier $g$ is robust at distance $\\epsilon / 2$ , no input $x ^ { \\prime }$ above exists and so $f ( x ) = y$ . Thus, the risk of $f$ is at most the robust risk of $g$ , so $R ( f ) \\leq \\beta$ . ",
+        "bbox": [
+            174,
+            327,
+            823,
+            369
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now, consider an input $( x , y ) \\sim \\mathcal { D }$ for which $f$ is not robust with detection at distance $\\epsilon$ . That is, either $f ( x ) \\neq y$ , or there exists an input $\\hat { x }$ at distance $d ( x , { \\hat { x } } ) \\leq \\epsilon$ such that $f ( \\hat { x } ) = \\hat { y } \\not \\in \\{ y , \\bot \\}$ . We will show that the defense $g$ is not robust for $x$ either (for attacks at distance up to $\\epsilon / 2$ .) ",
+        "bbox": [
+            174,
+            376,
+            823,
+            419
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "If $f ( x ) \\neq y$ , then by the same argument as above it cannot be the case that $g$ is robust at distance $\\epsilon / 2$ for $x$ . ",
+        "bbox": [
+            174,
+            425,
+            823,
+            454
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "So let us consider the case where $f ( \\hat { x } ) = \\hat { y } \\not \\in \\{ y , \\bot \\}$ . By the definition of $f$ , this means that for all $x ^ { \\prime }$ at distance at most $\\epsilon / 2$ from $\\hat { x }$ , we have $g ( x ^ { \\prime } ) = \\hat { y }$ . But, note that there exists a point $x ^ { * }$ that is at distance at most $\\epsilon / 2$ from both $\\hat { x }$ and $x$ . Since we must have $g ( x ^ { * } ) = \\hat { y }$ , we conclude that $g$ is not robust at distance $\\epsilon / 2$ for $x$ . ",
+        "bbox": [
+            174,
+            459,
+            825,
+            516
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Taking expectations over the distribution $\\mathcal { D }$ concludes the proof. ",
+        "bbox": [
+            174,
+            523,
+            596,
+            539
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/SHbhHHfePhP/SHbhHHfePhP.md

@@ -0,0 +1,551 @@
+# EQUIVARIANT GRAPH MECHANICS NETWORKS WITH CONSTRAINTS
+
+Wenbing Huang∗1, Jiaqi $\mathbf { H a n } ^ { * 2 }$ †, $\mathbf { Y u \ R o n g } ^ { \boxtimes 3 }$ , Tingyang $\mathbf { X } \mathbf { u } ^ { 3 }$ , Fuchun $\mathbf { S u n } ^ { \boxtimes 2 }$ , Junzhou Huang4
+
+1 Institute for AI Industry Research (AIR), Tsinghua University   
+2 Beijing National Research Center for Information Science and Technology (BNRist),   
+Department of Computer Science and Technology, Tsinghua University   
+3 Tencent AI Lab   
+4 Department of Computer Science and Engineering, University of Texas at Arlington   
+hwenbing@126.com, hanjq21@mails.tsinghua.edu.cn, yu.rong@hotmail.com   
+tingyangxu@tencent.com, fcsun@mail.tsinghua.edu.cn, jzhuang@uta.edu
+
+# ABSTRACT
+
+Learning to reason about relations and dynamics over multiple interacting objects is a challenging topic in machine learning. The challenges mainly stem from that the interacting systems are exponentially-compositional, symmetrical, and commonly geometrically-constrained. Current methods, particularly the ones based on equivariant Graph Neural Networks (GNNs), have targeted on the first two challenges but remain immature for constrained systems. In this paper, we propose Graph Mechanics Network (GMN) which is combinatorially efficient, equivariant and constraint-aware. The core of GMN is that it represents, by generalized coordinates, the forward kinematics information (positions and velocities) of a structural object. In this manner, the geometrical constraints are implicitly and naturally encoded in the forward kinematics. Moreover, to allow equivariant message passing in GMN, we have developed a general form of orthogonality-equivariant functions, given that the dynamics of constrained systems are more complicated than the unconstrained counterparts. Theoretically, the proposed equivariant formulation is proved to be universally expressive under certain conditions. Extensive experiments support the advantages of GMN compared to the state-of-the-art GNNs in terms of prediction accuracy, constraint satisfaction and data efficiency on the simulated systems consisting of particles, sticks and hinges, as well as two real-world datasets for molecular dynamics prediction and human motion capture.
+
+# 1 INTRODUCTION
+
+Representing and reasoning about the relations and dynamics of a group of interacting objects is among the core aspects of human intelligence (Tenenbaum et al., 2011; Ding et al., 2021; Gan et al., 2021). As a motivating example, we consider the N-body system (Kipf et al., 2018) where the movement of a single charged particle is attracted or repelled by other charged particles. Physicists have revealed that this process can be modeled by Newton’s laws along with the Coulomb force. One may wonder, however,
+
+![](images/23d917850ea3b5b0471939757fbfd4566a7cd350be4c0cfbb7058a27e6403e3f.jpg)  
+Figure 1: N-body vs. constrained N-body (red/blue balls denote positive/negative charges).
+
+if we can teach a machine to rediscover the underlying physics by solely observing the particles’ states. This thinking has inspired the study of learning to model interacting systems, which now is a prevailing topic in machine learning (Battaglia et al., 2016; Thomas et al., 2018; Kohler et al., 2019; ¨ Sanchez-Gonzalez et al., 2019; Fuchs et al., 2020; Martinkus et al., 2021; Satorras et al., 2021).
+
+Learning to model interacting systems is challenging. First, the systems are combinatorially complex, on account of that objects can be composed in combinatorially many possible arrangements (Battaglia et al., 2016). This challenge, to some extent, can be addressed by making use of Graph Neural Networks (GNNs) (Wu et al., 2020). By regarding objects as nodes and interactions as edges, GNNs extract information via message passing, which is able to characterize arbitrarily ordered objects and combinatorial relations. The second challenge is related to an important symmetry in physics: the model we use should be equivariant to any Euclidean transformation (translation/reflection/rotation) of the input. This complies with the fact that physics rules keep unchanged regardless of the reference coordinate system. Several works (Fuchs et al., 2020; Satorras et al., 2021) have investigated equivariance upon GNNs and exhibited remarkable benefits on N-body.
+
+Another challenge, though less explored, is that the systems could be geometrically constrained. Geometric constraints arise in common practical systems, for example, in robotics where the joints of mechanical arms should be linked one by one, or in biochemistry where the atoms of molecules are connected by chemical bonds. When modeling these constrained systems, it is crucial to enforce the model to output legal predictions. For instance, the lengths/angles of chemical bonds in a molecular closely determine its chemical property which will be changed dramatically if the structural constraints are broken. As mentioned above, equivariant GNNs (Fuchs et al., 2020; Satorras et al., 2021) have achieved desirable performance on the N-body system—this system, nevertheless, lacks of constraint. Considering constraints is not easy, as the dynamics of all elements within a constrained system evolve in a joint and complex manner. Unfortunately, to the best of our knowledge, there is no research (particularly among equivariant GNN methods) that learns to model the dynamical systems of multiple interacting objects under geometrical constraints.
+
+In this paper, we propose Graph Mechanics Network (GMN) that can tackle the above three challenges simultaneously: I. To cope with the combinatorial complexity, GMN takes advantage of graph models to encode the states of and interactions between objects, analogous to previous approaches. II. For the constraint satisfaction, GMN resorts to generalized coordinates, a well known notion in conventional mechanics to model the dynamics of structural objects. Here, a structural object (such as the stick and hinge in Fig. 1) is defined as a set of multiple rigidly connected particles. In GMN, the constraints are implicitly encoded in the forward kinematics that describes the Cartesian states as the function of generalized coordinates. This strategy can inherently maintain the constraints and requires no external regulation. III. GMN is equivariant. In GMN, we need to compute the interaction forces in the Cartesian space (see Eq. 5), and infer the accelerations of the generalized coordinates based on the inverse dynamics (see Eq. 6), both of which are learned by a general form of equivariant functions (see Eq. 11). Notably, the proposed equivariant formulation is more efficient to compute compared to the previous versions based on spherical harmonics (Thomas et al., 2018; Fuchs et al., 2020), or more general than the one developed by EGNN (Satorras et al., 2021). More importantly, we have theoretically discussed when and how our formulation can universally approximate any equivariant function.
+
+To evaluate the advantages of GMN, we have constructed a simulated dataset composed of three types of objects: particles, sticks and hinges, which is a complex case of the N-body system (Kipf et al., 2018) and can be used as building blocks for common systems. Under various scenarios in terms of different ratios of object types and different numbers of training data, we empirically verify the superiority of GMN compared to state-of-the-art models in prediction accuracy, constraint satisfaction and data efficiency. In addition, we also test the effectiveness of GMN on two real-world datasets: MD17 (Chmiela et al., 2017) and CMU Motion Capture (CMU, 2003).
+
+# 2 RELATED WORK
+
+Learning to simulate complex physical systems has been shown to greatly benefit from using GNNs. Interaction Network (IN) proposed by Battaglia et al. (2016) is the first attempt for this purpose, and it can be deemed as a special kind of GNNs to learn how the system interacts and how the states of particles evolve. Later researches have extended IN in different aspects: HRN (Mrowca et al., 2018) utilizes hierarchical graph convolution for tackling objects of various geometrical shapes and materials, NRI (Kipf et al., 2018) further explicitly infers the interactions with the help of a variational auto-encoder, and Hamiltonian graph networks (Sanchez-Gonzalez et al., 2019) equip GNNs with ordinary differential equations and Hamiltonian mechanics for energy conservation. However, all above approaches have ignored the symmetry in physics and the GNN models they use are not Euclidean equivariant. There is a subset of models (Ummenhofer et al., 2019; Sanchez-Gonzalez et al., 2020; Pfaff et al., 2020) that partially implement symmetries, but they only enforce translation equivariance but not rotation equivariance. On the other hand, it is nontrivial to enforce rotation equivariance. Tensor-Field networks (Thomas et al., 2018) uses filters built from spherical harmonics to allow 3D rotation equivariance, and this idea has been developed by SE(3) Transformer (Fuchs et al., 2020) that further takes the attention mechanism into account. Anther class of works (Finzi et al., 2020a; Hutchinson et al., 2021) resorts to the Lie convolution for the equivariance on any Lie group, based on lifting and sampling. Recently, EGNN (Satorras et al., 2021) has proposed a simple yet effective form of equivariant message passing on graphs, which does not require computationally expensive higher-order representations while still achieving better performance on N-body.
+
+As interpreted before, ensuring geometrical constraints is crucial for many practical systems, which, nevertheless, is seldom investigated in aforementioned works. Although several attempts (Yang et al., 2020; Finzi et al., 2020b) have been proposed for learning to enforce constraints, they explicitly augment the training loss with soft Lagrangian regulation and thus are completely data-driven and have no guarantee of generalization for limited training data. DeLaN (Lutter et al., 2019) also employs generalized coordinates to describe the kinematics of the rigid object. Nevertheless, it only target on the physical process of a single object, other than the complex systems with multiple rigid and structural objects that are the focus of this paper. In DPI-Net (Li et al., 2018), the BoxBath task does share the similar strategy to us by first predicting the canonical coordinates of the box and then using the forward kinematic model to obtain the Cartesian positions. However, the passing messages in DPI-Net are scalars other than directional vectors (positions, velocities, and accelerations) used in our work. After all, both DeLaN and DPI-Net never study equivariant models.
+
+# 3 GRAPH MECHANICS NEURAL NETWORK
+
+We begin with introducing the N-body system (Kipf et al., 2018), as illustrated in Fig. 1 (a). This system consists of $N$ interacting particles $\{ P _ { i } \} _ { i = 1 } ^ { N }$ of the same mass, and the kinematics states of each particle are defined as ${ \cal S } _ { i } = ( { \pmb x } _ { i } , { \pmb v } _ { i } )$ , where $\mathbf { \hat { x } } _ { i } , \mathbf { \hat { v } } _ { i } \in \mathbb { R } ^ { 3 }$ are the position and velocity vectors, respectively. There could be certain non-vector information of each particle (such as charge), which is represented by a $c$ -channel feature $\boldsymbol { h } _ { i } \in \mathbb { R } ^ { c \mathrm { ~ l ~ } }$ . Suppose the system we study is conservative and the dynamics is driven by the interaction force $f _ { i j } \in \mathbb { R } ^ { 3 }$ between any pair of particles $i$ and $j$ . According to Newton’s second law, the acceleration of particle $i$ , $\mathbf { } \mathbf { { a } } _ { i } \in \mathbb { R } ^ { 3 }$ is proportional to the aggregated force from other particles $\textstyle \sum _ { j \neq i } f _ { i j }$ . All symbols will be specified with a superscript $t$ for temporal denotations, e.g., $\boldsymbol { x } _ { i } ^ { t }$ indicating the position of particle $i$ at time $t$ . In this paper, we are mainly concerned with the prediction task: we need to seek out a function $\phi ( \{ ( S _ { i } ^ { 0 } , h _ { i } ^ { 0 } ) \} _ { i = 1 } ^ { N } )$ given the initial states $\{ S _ { i } ^ { 0 } \} _ { i = 1 } ^ { N }$ and features $\{ h _ { i } ^ { 0 } \} _ { i = 1 } ^ { N }$ to forecast the future states $\{ S _ { i } ^ { T } \} _ { i = 1 } ^ { N }$ at time $T$ .
+
+As presented in Introduction, two kinds of inductive biases have been explored previously. The first one is to apply the graph structure to capture the distribution of particle states and their interactions (Battaglia et al., 2016; Kipf et al., 2018), where, particularly, the particle states $S _ { i } ^ { 0 }$ (along with $h _ { i } ^ { 0 \setminus }$ ) are as node features and the interaction forces $f _ { i j } ^ { 0 }$ as edge messages. In this way, the transition function $\phi$ boils down to a GNN model. The second inductive bias is that $\phi$ should be equivariant to any translation/reflection/rotation of the input states. By saying equivariance, we imply
+
+$$
+\begin{array} { r } { \phi ( \{ ( g \cdot S _ { i } ^ { 0 } , h _ { i } ^ { 0 } ) \} _ { i = 1 } ^ { N } ) = { g \cdot \phi ( \{ ( S _ { i } ^ { 0 } , h _ { i } ^ { 0 } ) \} _ { i = 1 } ^ { N } ) } , \forall g \in \mathcal { O } ( 3 ) , \forall S _ { i } ^ { 0 } , \forall h _ { i } ^ { 0 } . } \end{array}
+$$
+
+Here, $\mathcal { O } ( 3 )$ defines the 3D orthogonal group (Fuchs et al., 2020) that consists of translation, reflection and rotation transformations; $g \cdot \bar { S _ { i } ^ { 0 } }$ denotes to perform transformation $g$ on the states $S _ { i } ^ { 0 }$ , and it is instantiated as $\pmb { R } ( \pmb { x } _ { i } ^ { 0 } + \pmb { b } )$ for the position and $\mathbf { \bar { \boldsymbol { R } } }  { \boldsymbol { v } } _ { i } ^ { 0 }$ for the velocity, where $\boldsymbol { R } \in \mathbb { R } ^ { 3 \times 3 }$ is the orthogonal matrix and $\pmb { b } \in \mathbb { R } ^ { 3 }$ is the translation vector.
+
+Several works (Thomas et al., 2018; Kohler et al., 2019; Fuchs et al., 2020; Satorras et al., 2021) ¨ have investigated both inductive biases, among which EGNN (Satorras et al., 2021) has achieved promising performance on N-body. The typical process in EGNN iterates the following steps:
+
+$$
+{ \pmb a } _ { i } ^ { l } , h _ { i } ^ { l } = \sum _ { j } \varphi _ { \mathrm { e g n n } } ( { \pmb x } _ { j i } ^ { l - 1 } , h _ { i } ^ { l - 1 } , h _ { j } ^ { l - 1 } , e _ { j i } ) ,
+$$
+
+$$
+\pmb { v } _ { i } ^ { l } = \psi ( h _ { i } ^ { l - 1 } ) \pmb { v } _ { i } ^ { l - 1 } + \pmb { a } _ { i } ^ { l } ,
+$$
+
+$$
+\begin{array} { r } { \pmb { x } _ { i } ^ { l } = \pmb { x } _ { i } ^ { l - 1 } + \pmb { v } _ { i } ^ { l } , } \end{array}
+$$
+
+where the superscript $l$ denotes the $l$ -th layer; the acceleration $\mathbf { \Delta } \mathbf { a } _ { i } ^ { l }$ returned by the message aggregation of $\varphi _ { \mathrm { e g n n } }$ in Eq. 2 is adopted for the update of the velocity $\pmb { v } _ { i } ^ { l }$ in Eq. 3 (multiplied by a scalar $\psi ( h _ { i } ^ { l - 1 } ) \in \mathbb { R } )$ ), followed by the renovation of the position $\mathbf { \boldsymbol { x } } _ { i } ^ { l }$ in Eq. 4. The formu
+
+lation of $\varphi _ { \mathrm { e g n n } }$ is physically reasonable, since the interaction (actually the Coulomb force) between particles $i$ and $j$ truly depends on their relative position $\pmb { x } _ { j i } ^ { l - 1 } = \pmb { x } _ { i } ^ { l - 1 } - \pmb { x } _ { j } ^ { l - 1 }$ , node features $h _ { i } ^ { l - 1 }$ and $h _ { j } ^ { l - 1 }$ , and edge feature $e _ { j i }$ . To enable equivariant message passing, EGNN has developed a specific form of $\varphi _ { \mathrm { e g n n } }$ to let $\mathbf { \Delta } \mathbf { a } _ { i } ^ { l }$ be equivariant and $h _ { i } ^ { l }$ be invariant in terms of the input $\pmb { x } _ { j i } ^ { l - 1 }$ , which will be presented in Eq. 10. Notice that the computations for $\mathbf { \mathcal { f } } _ { i } ^ { l }$ and $h _ { i } ^ { l }$ are actually by two different functions, and we have abbreviated them into one in Eq. 2 (and also Eq. 5 later), since they share the same inputs; besides, their parameters are shared following EGNN.
+
+# 3.1 OUR GENERAL ARCHITECTURE
+
+Despite the desirable performance on N-body, existing methods are incapable of maintaining the geometric constraint. In this section, we design a general architecture that intrinsically meets the requirement of geometry constraints by making use of the generalized coordinates.
+
+We define $\mathcal { O } _ { k } = \{ P _ { i } \} _ { i = 1 } ^ { n _ { k } }$ a structural object composed of $n _ { k }$ rigidly connected particles. Fig. 1 (b) illustrates two examples of the structural object, the stick with 2 connected particles and the hinge with 3 particles. To preserve the distance, the dynamics of the two particles on a stick should be updated in a joint way, rather than fulfilling the independent process in EGNN (Eq. 3 and 4). Besides, the force on each particle within $\mathcal { O } _ { k }$ will indirectly influence the dynamics of others through the physical connections. This requires us to analyze the dynamics of the particles in $\mathcal { O } _ { k }$ as a whole, which is implemented by generalized coordinates. There could be multiple generalized coordinates for each $\mathcal { O } _ { k }$ , some located in the Cartesian space but some in the angle space. For instance, the states of a stick can be decoupled by two independent sets of generalized coordinates: the state of particle 1 as the Cartesian coordinates and the relative rotation angles of particle 2 to 1 as the angle coordinates. For conciseness, this section only focus on the Cartesian part which essentially determines the local coordinates in $\mathcal { O } _ { k }$ , with providing full examples in $\ S \ 3 . 3$ . We denote the position, velocity and acceleration of the generalized Cartesian coordinates as $\pmb q _ { k }$ , $\dot { \pmb q } _ { k }$ and $\ddot { \pmb q } _ { k }$ , respectively.
+
+We now detail how to update the states of $\mathcal { O } _ { k }$ . In Fig. 2, we first compute the interaction force between each particle and others, and aggregate information of all particles within each structural object to infer the acceleration of the generalized coordinates (which is termed as the generalized acceleration henceforth) by inverse dynamics.
+
+Then, the dynamical updates are carried out in the space of the generalized coordinates. Finally, the updated generalized coordinates will be projected back to the particles’ states via the forward kinematics.
+
+$$
+\begin{array} { r l } & { f _ { i } ^ { l } , h _ { i } ^ { l } = \displaystyle \sum _ { j } \varphi _ { 1 } ( x _ { j i } ^ { l - 1 } , h _ { i } ^ { l - 1 } , h _ { j } ^ { l - 1 } , e _ { j i } ) _ { ; } } \\ & { \qquad \dot { q } _ { k } ^ { l } = \displaystyle \sum _ { i \in \mathcal { O } _ { k } } \varphi _ { 2 } ( f _ { i } ^ { l } , x _ { k i } ^ { l - 1 } , v _ { k i } ^ { l - 1 } ) , } \\ & { \qquad \dot { q } _ { k } ^ { l } = \psi ( \displaystyle \sum _ { i \in \mathcal { O } _ { k } } h _ { i } ^ { l - 1 } ) \dot { q } _ { k } ^ { l - 1 } + \ddot { q } _ { k } ^ { l } , } \\ & { \qquad q _ { k } ^ { l } = q _ { k } ^ { l - 1 } + \dot { q } _ { k } ^ { l } , } \\ & { \qquad x _ { i } ^ { l } , v _ { i } ^ { l } = \mathrm { F K } ( q _ { k } ^ { l } , \dot { q } _ { k } ^ { l } ) , \forall i \in \mathcal { O } _ { k } , } \end{array}
+$$
+
+![](images/30f18d90a47faa64882c215213f5681603681c4d535ccefff0bae32b889835d1.jpg)  
+Figure 2: The flowchart of our GMN.
+
+where, the elements of the system can be described in two views, $\{ \mathcal { O } _ { k } \} _ { k = 1 } ^ { K }$ as the object-level view and $\{ P _ { i } \} _ { i = 1 } ^ { N }$ as the particle-level view; for distinction, we index the structural object with the subscript $k$ and particles with or $j$ . We explain each equation separately.
+
+Interaction force (Eq. 5). The interaction force $\mathbf { \mathcal { f } } _ { i } ^ { l }$ is computed analogous to Eq. 2. EGNN straightly regards the interaction force to be the acceleration of each particle in Eq. 2. But here, given the constraints between particles, we record the force as an intermediate variable that will contribute to the inference of the generalized acceleration in the next step.
+
+Inverse dynamics (Eq. 6). This step is the core of our methodology. The generalized acceleration $\ddot { q } _ { k } ^ { l }$ is dependent to the forces $\mathbf { \mathcal { f } } _ { i } ^ { l }$ on all particles within $\mathcal { O } _ { k }$ , and their relative positions $\pmb { x } _ { k i } ^ { l - 1 } = \pmb { x } _ { i } ^ { l - 1 } - \pmb { q } _ { k } ^ { l - 1 }$ and relative velocities $\pmb { v } _ { k i } ^ { l - 1 } = \pmb { v } _ { i } ^ { l - 1 } - \dot { \pmb { q } } _ { k } ^ { l - 1 }$ with regard to the generalized coordinates. The formulation of Eq. 6 is physics-inspired. In Appendix (Eq. 26), we have analytically derived the dynamics of hinges, where the acceleration of the hinge is indeed related to the forces, relative positions and relativmechanics, since the cross product $\pmb { x } _ { k i } ^ { l - 1 } \times \pmb { f } _ { i } ^ { l }$ of all particles in each hinge. This is reasoyields the torque, and the relative velocity $\pmb { v } _ { k i } ^ { l - 1 }$ inis related to the centrifugal force of particle $i$ around , both of which influence the acceleration $\ddot { \pmb q } _ { k }$ Different from the analytical form which is always complex and hard to compute in practice, we will employ a learnable and equivariant function with universal expressivity. The details are in $\ S 3 . 2$ .
+
+Generalized update (Eq. 7-8). The updates of the generalized coordinates are akin to Eq. 3 and 4 in EGNN, as the dimensions of the generalized coordinates have been made independent. Notice that in Eq. 7 the scalar factor for $\dot { \pmb q } _ { k } ^ { l - 1 }$ takes as input the summation of all hidden features, which is a generalized form of Eq. 3 for multiple particles in ${ \mathcal { O } } _ { k }$ .
+
+Forward kinematics (Eq. 9). Once the generalized coordinates have been refreshed, we can derive the states of all particles in $\mathcal { O } _ { k }$ by proceeding the forward kinematics. Different system of $\mathcal { O } _ { k }$ could have different type of the forward kinematics. Here we denote it as the function $\operatorname { F K } ( \cdot )$ in general, while providing the specifications in $\ S \ 3 . 3$ .
+
+Our method will reduce to EGNN if setting the generalized coordinates as the states of each particle and utilize the identify map in Eq. 6 and 9. Alg. 1 has summarized the updates for all objects.
+
+# 3.2 EQUIVARIANT MESSAGE PASSING
+
+As shown in Eq. 1, the Euclidean equivariance on the estimation function $\phi$ is necessary for ensuring the physical symmetry. When considering this property in our case, we demand the interaction force (Eq. 5) and generalized acceleration (Eq. 6) to be equivariant with respect to orthogonal transformations, while other equations are already equivariant2. EGNN (Satorras et al., 2021) has developed a particular orthogonality-equivariant form for the acceleration output in Eq. 2:
+
+$$
+\varphi _ { \mathrm { e g n n } } ( \pmb { x } , h ) : = \pmb { x } \sigma _ { w } ( \| \pmb { x } \| _ { 2 } ^ { 2 } , h ) ,
+$$
+
+where $\sigma _ { w } ( \cdot )$ is an arbitrary Multi-Layer Perceptron (MLP) with parameter $w$ , and we have abbreviated other non-vector terms in Eq. 2 as $h$ . This formulation does satisfy the rotation equivariance, but it is unknown if it can be generalized to functions (such as Eq. 6) with multiple input vectors, and more importantly, its representation completeness is never explored rigorously. In this section, we propose a general form of orthogonality-equivariant functions with necessary theoretical guarantees.
+
+Without loss of generality, the target function we would like to enforce equivariance is denoted as $\varphi ( Z , h ) : \mathbb { R } ^ { d \times m } \times \mathbb { R } ^ { c }  \mathbb { R } ^ { d \times m ^ { \prime } }$ . We define the below formulation,
+
+$$
+\varphi ( Z , h ) : = Z \sigma _ { w } ( Z ^ { \top } Z , h ) .
+$$
+
+It is easy to justify the function $\varphi ( Z , h )$ in Eq. 11 is equivariant to any orthogonal matrix i.e., $\varphi ( O Z , h ) = O \varphi ( Z , h )$ , $\forall O \in \mathbb { R } ^ { d \times d }$ , $O ^ { \top } O = I$ . Apparently, Eq. 11 reduces to Eq. 10 by setting the number of vectors in $z$ as 1, namely, $m = m ^ { \prime } = 1$ . We immediately have the following theory.
+
+Theorem 1. If $m \geq d$ and the row rank of $z$ is full, i.e. $r a n k ( Z ) = d ,$ , then for any continuous orthogonality-equivariant function ${ \hat { \varphi } } ( Z , h )$ , there must exist an MLP $\sigma _ { w }$ satisfying $\parallel \varphi ( \boldsymbol { Z } , h ) \mathrm { ~ - ~ }$ $\hat { \varphi } ( Z , h ) \rVert < \epsilon$ for arbitrarily small error $\epsilon$ .
+
+The proof employs the universality of MLP (Cybenko, 1989; Hornik, 1991), with the entire details deferred in Appendix. Theorem 1 is nutritive, as it characterizes the rich expressivity of formulating the equivariant function via Eq. 11. The condition holds in general for the function like Eq. 6 whose input $Z = ( f _ { i } , x _ { k i } , v _ { k i } ) \in \bar { \mathbb { R } } ^ { 3 \times 3 }$ is of full rank when the force, position and velocity expand the whole space. Indeed, this condition holds with probability 1, stated by the following corollary.
+
+Corollary 1. Assume $m \geq d$ , and also the entries of $z$ are drawn independently from a distribution that is absolutely continuous with respect to the Lebesgue measure in $\mathbb { R }$ . Then, almost surely, the conclusion of Theorem 1 holds.
+
+When the condition $m \geq d$ is invalid, the universal approximation still maintains if restricted in the linear subspace expanded by the columns of $z$ .
+
+Corollary 2. For any continuous orthogonality-equivariant function ${ \hat { \varphi } } ( Z , h )$ located in the linear subspace expanded by the columns of $z$ , the conclusion of Theorem 1 holds universally.
+
+Corollary 2 tells that the message passing $\varphi _ { \mathrm { e g n n } }$ in Eq. 10 is not universally expressive since $m < d$ , and can only fit the vectors parallel to $_ { \textbf { \em x } }$ (i.e. the relative position). Yet, $\varphi _ { \mathrm { e g n n } }$ is still physically complete for the Coulomb force that is oriented by the relative position between two particles.
+
+In our experiments, we find that more stable performance is delivered by further adding the normalization term specifically when $m > 1$
+
+where $\| \cdot \| _ { F }$ computes the Frobenius norm. Notice that adding normalization does not change the conclusions in Theorem 1 and its two corollaries, since the norm is also a function of $Z ^ { \top } \bar { Z }$ that can be approximated by MLP. We implement $\varphi _ { 1 }$ in Eq. 5 and $\varphi _ { 2 }$ in Eq. 6 by using the general formulation Eq. 12, where Z = xl−1ji and $\pmb { Z } \overset { \cdot } { = } ( \mathbf { f } _ { i } ^ { l } , \mathbf { x } _ { k i } ^ { \bar { l } - 1 } , \mathbf { v } _ { k i } ^ { l - 1 } )$ , respectively. Note that for the update of hidden feature $h _ { i } ^ { l }$ in Eq. 5, we do not need equivariance but invariance, hence we set $h _ { i } ^ { l } = \sigma _ { w } \big ( Z ^ { \top } Z / \| Z ^ { \top } Z \| _ { F } , h _ { i } ^ { l - 1 } \big )$ by just keeping the invariant part in Eq. 12.
+
+# 3.3 IMPLEMENTATIONS OF FORWARD KINEMATICS
+
+Implementation of hinges. A hinge, as displayed in Fig.3 (a), consists of three particles 0, 1, 2, and two sticks 01 and 02. The freedom degrees of this system can be explained in this way: particle 0 moves freely, and particles 1 and 2 can only rotate round particle 0 owing to the length constraint by the two sticks. Hence, the generalized coordinates include the states of particle 0 denoted as $\bar { \pmb q _ { 0 } } \in \mathbb { R } ^ { 3 }$ and the rotation Euler angles of stick 01 as $\theta _ { 0 1 } \in \mathbb { R } ^ { 3 }$ and 02 as $\bar { \pmb { \theta } _ { 0 2 } } ~ \in ~ \mathbb { R } ^ { 3 }$ .
+
+As low $\pmb q _ { 0 }$ are Cartesian, the dynamical upirectly Eq. 5-8. With the forces $\{ f _ { i } ^ { l } \} _ { i = 0 } ^ { 3 }$   
+estimated in Eq. 5 and acceleration $\ddot { q } _ { 0 } ^ { l }$ by Eq. 6,   
+the angle acceleration of $\pmb { \theta } _ { 0 1 }$ is calculated as   
+$\ddot { \pmb { \theta } } _ { 0 1 } ^ { l } = ( \mathbf { x } _ { 0 1 } ^ { l - 1 } \times ( \mathbf { f } _ { 1 } ^ { l } - \ddot { \pmb { q } } _ { 0 } ^ { l } ) ) / \| \mathbf { x } _ { 0 1 } ^ { l - 1 } \| ^ { 2 }$ accord  
+ing to rigid mechanics, where the numerator is   
+the relative torque, the denominator is the mo  
+ment of inertia under unit mass, and $\times$ means   
+$\dot { \theta } _ { 0 1 } ^ { l } = \psi ^ { \prime } \dot { ( h _ { 0 } ^ { l - 1 } + h _ { 1 } ^ { l - 1 } + h _ { 2 } ^ { l - 1 } ) } \dot { \theta } _ { 0 1 } ^ { l - 1 } + \ddot { \theta } _ { 0 1 } ^ { l }$ ity issimi$\pmb { \theta } _ { 0 1 }$
+
+![](images/28129ed9e151b197c99d1a7294638305b667be197f94ffaba19a3a7093256eaf.jpg)  
+Figure 3: Illustrations of hinges and sticks.
+
+he forward kinematics can be conducted without it. In detail, the forward kinematics in Eq. 9 is:
+
+$$
+\begin{array} { r } { \pmb { x } _ { 1 } ^ { l } = \pmb { q } _ { 0 } ^ { l } + \mathrm { r o t } ( \dot { \pmb { \theta } } _ { 0 1 } ^ { l } ) \pmb { x } _ { 0 1 } ^ { l - 1 } , \quad \pmb { v } _ { 1 } ^ { l } = \dot { \pmb { q } } _ { 0 } ^ { l } + \dot { \pmb { \theta } } _ { 0 1 } ^ { l } \times \pmb { x } _ { 0 1 } ^ { l } , } \end{array}
+$$
+
+where $\mathrm { r o t } ( \dot { \pmb \theta } _ { 0 1 } ^ { l } )$ indicates the rotation matrix around the direction of $\dot { \pmb \theta } _ { 0 1 } ^ { l }$ by absolute angle $\lVert \dot { \pmb \theta } _ { 0 1 } ^ { l } \rVert$ .   
+The dynamic updates for particle 2 is similar. We put the whole details into Alg. 1 in Appendix.
+
+Implementation of sticks. For a stick with particles 1 and 2 in Fig 3 (b), we choose the center as the generalized Cartesian coordinate $\pmb q _ { 0 }$ , and the rotation of particle $1 \theta _ { 0 1 }$ and particle 2 $\pmb { \theta } _ { 0 2 }$ $\pmb { \theta } _ { 0 1 } = \pmb { \theta } _ { 0 2 } )$ ) as the generalized angle coordinates. The dynamics propagation of $\pmb q _ { 0 }$ is given by Eq. 5-8. There are two choices to compute $\ddot { q } _ { 0 } ^ { l }$ , one using the general form in Eq. 6 and the other one leveraging a simplified version as $\begin{array} { r } { \ddot { { \bf q } } _ { 0 } ^ { \bar { l } } = \sum _ { i \in \mathcal { O } _ { k } } \varphi ( { f } _ { i } ^ { \bar { l } } ) } \end{array}$ by explicitly omitting the relative position and velocity. The physical motivation of introducing the simplified version is that the acceleration of a stick center is only affected by the forces according to the theorem of the motion of the center of mass. The angle accelerations are $\ddot { \pmb { \theta } } _ { 0 1 } ^ { l } = ( \mathbf { x } _ { 0 1 } ^ { l - 1 } \times \mathbf { f } _ { 1 } ^ { l } + \mathbf { x } _ { 0 2 } ^ { l - 1 } \times \mathbf { f } _ { 2 } ^ { l } ) / ( \lVert \mathbf { x } _ { 0 1 } ^ { l - 1 } \rVert ^ { 2 } + \lVert \mathbf { x } _ { 0 2 } ^ { l - 1 } \rVert ^ { 2 } )$ , and the velocity becomes $\dot { \theta } _ { 0 1 } ^ { l } = \psi ^ { \prime } ( h _ { 1 } ^ { l - 1 } + h _ { 2 } ^ { l - 1 } ) \dot { \theta } _ { 0 1 } ^ { l - 1 } + \ddot { \theta } _ { 0 1 } ^ { l }$ . The states of particles 1 and 2 are renewed as the same as Eq. 13.
+
+Learnable FK. Besides the above hand-crafted FK, we propose a learnable variant by replacing Eq. (7-9) with the update $\pmb { v } _ { i } ^ { l } = \phi ( h _ { i } ^ { l - 1 } ) \pmb { v } _ { i } ^ { l - 1 } + \rho ( \ddot { \pmb { q } } _ { k } ^ { l } , \pmb { x } _ { k i } ^ { l - 1 } , \pmb { f } _ { i } ^ { l } ) , \pmb { x } _ { i } ^ { l } = \pmb { x } _ { i } ^ { l - 1 } + \pmb { v } _ { i } ^ { l }$ , where $\rho$ is the equivariant function via Eq. 12. Full details are provided in Appendix I.
+
+Table 1: Prediction error $( \times 1 0 ^ { - 2 } )$ on various types of systems. The header of each column ${ } ^ { 6 6 } p , s , h ^ { \prime \prime }$ denotes the scenario with $p$ isolated particles, $s$ sticks and $h$ hinges. Results averaged across 3 runs.   
+
+<table><tr><td colspan="6">|Train| = 500</td><td colspan="5">|Train] = 1500</td></tr><tr><td></td><td>1,2.0</td><td>2.0,1</td><td>3,2,1</td><td>0,10.0</td><td>5.3,3</td><td>1,2.0</td><td>2.0,1</td><td>3,2,1</td><td>0,10.0</td><td>5,3,3</td></tr><tr><td>Linear</td><td>8.23±0.00</td><td>7.55±0.00</td><td>9.76±0.00</td><td>11.36±0.00 1</td><td>11.62±0.00</td><td></td><td>8.22±0.00 7.55±0.009.76±0.00 1136±0.0011.62±0.00</td><td></td><td></td><td></td></tr><tr><td>GNN</td><td>5.33±0.07</td><td>5.01±0.08</td><td>7.58±0.08</td><td>9.83±0.04</td><td>9.77±0.02</td><td></td><td>3.61±0.13 3.23±0.07 4.73±0.11</td><td></td><td>7.97±0.44</td><td>7.91±0.31</td></tr><tr><td>TFN</td><td>11.54±0.38 9.87±0.27</td><td></td><td>11.66±0.08</td><td>13.43±0.31</td><td>12.23±0.12</td><td></td><td>5.86±0.35 4.97±0.23 8.51±0.14 11.21±0.21</td><td></td><td></td><td>10.75±0.08</td></tr><tr><td>SE(3)-Tr.</td><td>5.54±0.06</td><td>5.14±0.03</td><td>8.95±0.04</td><td>11.42±0.01</td><td>11.59±0.01</td><td></td><td>5.02±0.03 4.68±0.05 8.39±0.02</td><td></td><td>10.82±0.03</td><td>10.85±0.02</td></tr><tr><td>RF</td><td>3.50±0.17</td><td>3.07±0.24</td><td>5.25±0.44</td><td>7.59±0.25</td><td>7.73±0.39</td><td></td><td>2.97±0.15 2.19±0.11 3.80±0.25</td><td></td><td>5.71±0.31</td><td>5.66±0.27</td></tr><tr><td>EGNN</td><td>2.81±0.12</td><td>2.27±0.04</td><td>4.67±0.07</td><td>4.75±0.05</td><td>4.59±0.07</td><td></td><td>2.59±0.10 1.86±0.02 2.54±0.01</td><td></td><td>2.79±0.04</td><td>3.25±0.07</td></tr><tr><td>EGNNReg</td><td>2.94±0.01</td><td>2.66±0.06</td><td>7.01±0.34</td><td>5.03±0.08</td><td>6.31±0.04</td><td></td><td>2.74±0.08 1.58±0.03 2.62±0.05</td><td></td><td>3.03±0.07</td><td>3.07±0.04</td></tr><tr><td>GMN</td><td>1.84±0.02</td><td>2.02±0.02</td><td>2.48±0.04</td><td>2.92±0.04</td><td>4.08±0.03</td><td></td><td>1.68±0.04 1.47±0.03 2.10±0.04</td><td></td><td>2.32±0.02</td><td>2.86±0.01</td></tr></table>
+
+# 4 EXPERIMENTS
+
+# 4.1 SIMULATION DATASET: CONSTRAINED N-BODY
+
+Datasets. We inherit the 3D extension of Fuchs et al. (2020) based on the N-body simulation introduced in Kipf et al. (2018). For each trajectory, we provide the initial states of the system $\{ S _ { i } ^ { 0 } \} _ { i = 1 } ^ { N }$ , the particles’ charges $\{ c _ { i } \in ( - 1 , 1 ) \} _ { i = 1 } ^ { \tilde { N } }$ and a configuration indicating which particles are connected by sticks or hinges. The task is to predict the final positions $\{ \pmb { x } _ { i } ^ { T } \} _ { i = 1 } ^ { N }$ of the particles when $T = 1 0 0 0$ . The validation and testing sets contain 2000 trajectories. We evaluate the prediction error by the MSE metric. Compared with the simulation conducted in Fuchs et al. (2020); Satorras et al. (2021), our dataset is more challenging in three senses: 1. We consider systems with multiple scales, including 5, 10, and 20 particles in total, respectively. 2. We introduce to the system the dynamics of hinges and sticks (depicted in Appendix B), and construct various combinations between these objects. 3. We investigate the performance of each model across different scales of training set, e.g., 500 and 1500, to see how the models perform with scarce or relatively abundant training data. The system consisting of $p$ isolated particles, $s$ sticks and $h$ hinges, is abbreviated as $( p , s , h )$ .
+
+Implementation details. Following Satorras et al. (2021), we use a linear mapping of the scale of initial velocity $\vert \vert \pmb { v } _ { i } ^ { 0 } \vert \vert _ { 2 }$ as the input node feature $h _ { i } ^ { 0 }$ . The edge feature is provided by a concatenation of the product of charges $\mathbf { } c _ { i } \mathbf { c } _ { j }$ and an edge type indicator $I _ { i j }$ , where $I _ { i j }$ is valued as 0 if node $i$ and $j$ are disconnected, 1 if connected by a stick, and 2 if connected by a hinge. Note that this edge type indicator is an augmentation over the original setting in EGNN, designed to enforce EGNN and other baselines the ability to distinguish different types of edges, namely, with or without constraints. Other settings including the hyper-parameters are introduced in Appendix E.
+
+Comparison with SOTAs. Table 1 reports the performance of GMN and various compared models: EGNN (Satorras et al., 2021) and its regulated version EGNNReg, SE(3)-Transformer (Fuchs et al., 2020), Radial-Field (RF) (Kohler et al., 2019), Tensor-Field-Network (TFN) (Thomas et al., 2018), ¨ and other two baselines, GNN and the Linear prediction (Satorras et al., 2021). Regarding EGNN and EGNNReg, they share the same backbones (i.e. $\varphi _ { 1 }$ and $\psi$ ) and training hyper-parameters (learning rates, layer number, etc) with our GMN for a fair comparison. For EGNNReg, we explicitly involve a regularization term during training by enforcing the geometrical constraints, namely preserving the lengths between two particles on sticks and hinges; the regularization factor is ranged from 0.01 to 0.1, where the value giving the best performance is selected. The default settings of SE(3)-Transformer and TFN perform poorly on our experiments, hence we have tried our best to tune their hyper-parameters by validation. From Table 1, we have these observations:
+
+1. GMN achieves the best performance in all scenarios, suggesting its general superiority. 2. GMN is more robust when the complexity of the system increases. On $| \mathrm { T r a i n } | = 5 0 0$ , for example, the performance of GMN degenerates slightly by increasing the number of particles and hinges (e.g. from (1,2,0) to (3,2,1)), while other methods (such as EGNN) drops significantly. 3. Reducing the training size will hinder the performance of all compared methods remarkably. On the contrary, GMN still performs promisingly in general. For instance, on (3,2,1), EGNNReg becomes much worse from 2.62 to 7.01 when the volume of training data is decreased from 1500 to 500, whereas the change of GMN is smaller (2.10 v.s. 2.48). This is reasonable as GMN has explicitly encoded the constraints as opposed to EGNN and EGNNReg that learn to remember constraints by training.
+
+Table 2: Generalization across different systems. All models are trained in the (3,2,1) scenario.   
+
+<table><tr><td></td><td colspan="4">|Train| = 500</td><td colspan="4">|Train|= 1500</td></tr><tr><td></td><td>3,2,1</td><td>2,4,0</td><td>1,0,3</td><td>Average</td><td>3,2,1</td><td>2,4.0</td><td>1,0,3</td><td>Average</td></tr><tr><td>GNN</td><td>7.58</td><td>8.06</td><td>8.37</td><td>8.00</td><td>4.73</td><td>4.98</td><td>5.58</td><td>5.10</td></tr><tr><td>EGNN</td><td>4.67</td><td>3.42</td><td>4.40</td><td>4.16</td><td>2.54</td><td>2.75</td><td>3.49</td><td>2.93</td></tr><tr><td>EGNNReg</td><td>7.01</td><td>4.49</td><td>6.62</td><td>6.04</td><td>2.62</td><td>2.62</td><td>4.29</td><td>3.18</td></tr><tr><td>GMN</td><td>2.48</td><td>2.53</td><td>3.28</td><td>2.76</td><td>2.10</td><td>2.18</td><td>2.65</td><td>2.31</td></tr></table>
+
+Data efficiency. Fig. 4 depicts the prediction errors on (3,2,1) when the training size varies. It is observed that GMN acts steadily, justifying its benefit in data efficiency. Once again, both EGNN and EGNNReg deliver much worse performance when the training size is small, and they approach GMN when the training dataset is enlarged sufficiently. In physics, it is important to ensure the physics rules that are discovered by a relatively small number of experiments to be general enough for explaining universal phenomena. Hence, data efficiency, as a key advantage of GMN, comes as an important requirement for learning to model physical systems. Besides, by the comparison between GNN and other equivariant models, it is seen that equivariance is a crucial point for performance guarantee.
+
+![](images/724f0bafd929fda038083672bbb5a3851f26d721719cfbbd0555402ff59014f3.jpg)  
+Figure 4: Data efficiency.
+
+The generalization capability across different systems. It is interesting to check how the models perform when trained on one system but tested on others. Hence, Table 2 tests the generalization from (3,2,1) to (2,4,0) and (1,0,3). Interestingly, the performances of all models on new systems are comparable with the original environment. We conjecture that this ability could be attributed to the usage of GNN in capturing the combination diversity of the objects. As before, GMN performs best.
+
+Ablation studies. 1. The function $\varphi _ { 2 }$ is designed to be equivariant in Eq. 12. To justify this necessity, we replace $\varphi _ { 2 }$ with an MLP of the same size, and report the errors in Table 3, from which we confirm that removing equivariance incurs detriment to the performance. 2. The default setting of GMN in Eq. 6 is leveraging unshared acceleration inference $\bar { \varphi _ { 2 } } ( f _ { i } ^ { l } )$ for sticks and $\varphi _ { 2 } ( f _ { i } ^ { l } , \pmb { x } _ { k i } ^ { l - 1 } , \pmb { v } _ { k i } ^ { l - 1 } )$ ifor hinges. Here
+
+Table 3: Ablations. “O.F.” denotes numerical over-flow.   
+
+<table><tr><td>|Train|=500 |Train =1500 3,2,1 5,3,3 3,2,1 5,3,3</td></tr><tr><td>GMN</td></tr><tr><td>2.48 4.08 2.10 2.86 GMN-L 3.19 4.34 2.28 3.03</td></tr><tr><td>w/o Equivariance 3.74 4.41 2.46 3.29</td></tr><tr><td>2 with U 1 一 -1) 2.86 4.15 2.20 3.00 ki ，</td></tr><tr><td>i with Uki shared 3.86 4.25 2.30 2 ）， 3.10</td></tr><tr><td>2 with only f 3.10 4.39 2.34 4.19</td></tr><tr><td>2 with only f,shared 2.91 4.94 2.39 3.45</td></tr><tr><td>w/o Normalization 3.15 O.F. O.F. O.F.</td></tr></table>
+
+or unshared parameters. Applying identical we investigate different cases by assigning the identical form of $\varphi _ { 2 } ( f _ { i } ^ { l } , \pmb { x } _ { k i } ^ { l - 1 } , \pmb { v } _ { k i } ^ { l - 1 } )$ mostly outperforms the case by us- for sticks and hinges with shared ing $\varphi _ { 2 } ( \pmb { f } _ { i } ^ { l } )$ , probably owing to the better expressivity of the former version. Yet, both cases are worse than our design, implying that the dynamics of sticks and hinges should be modeled distinctly. 3. We have introduced a normalization term in Eq. 12. Table 3 demonstrates that eliminating this term leads to divergence during training, possibly owing to the numerical instability in the forward/backward propagation. 4. We have also implemented GMN-L that replaces the hand-crafted FK in GMN with a learnable black-box equivariant function. GMN-L outperforms EGNN in various settings, verifying the validity of using our proposed equivariant message passing layer and the object-level message $\ddot { \pmb q } _ { k }$ in Eq. 6. Yet, GMN-L still yields minor gap with GMN, implying the benefit of involving domain knowledge. The full results are deferred to Appendix I.
+
+# 4.2 APPLICATIONS ON REAL-WORLD DATASETS
+
+This subsection introduces how to apply GMN to practical applications including MD17 (Chmiela et al., 2017) and CMU Motion Capture (CMU, 2003). It is not required to manually derive the entire kinematics for these complex systems; instead, each input system is decomposed as a set of particles and sticks (e.g., the circles in Fig. 5), which can be directly processed by our current formulation of GMN without any modification. The core is modeling partial length-constraints of the input system with disjoint sticks. The full details of the kinematics decomposition trick are in Appendix C.
+
+Table 4: Prediction error $( \times 1 0 ^ { - 2 } )$ on MD17 dataset. Results averaged across 3 runs.   
+
+<table><tr><td></td><td>Aspirin</td><td>Benzene</td><td></td><td>Ethanol Malonaldehyde Naphthalene Salicylic</td><td></td><td></td><td>Toluene</td><td>Uracil</td></tr><tr><td>RF</td><td>10.94±0.01</td><td>103.72±1.29</td><td>4.64±0.01</td><td>13.93±0.03</td><td>0.50±0.01</td><td>1.23±0.01</td><td>10.93±0.04</td><td>0.64±0.01</td></tr><tr><td>TFN</td><td>12.37±0.18</td><td>58.48±1.98</td><td>4.81±0.04</td><td>13.62±0.08</td><td>0.49±0.01</td><td>1.03±0.02</td><td>10.89±0.01</td><td>0.84±0.02</td></tr><tr><td>SE(3)-Tr.</td><td>11.12±0.06</td><td>68.11±0.67</td><td>4.74±0.13</td><td>13.89±0.02</td><td>0.52±0.01</td><td>1.13±0.02</td><td>10.88±0.06</td><td>0.79±0.02</td></tr><tr><td>EGNN</td><td>14.41±0.15</td><td>62.40±0.53</td><td>4.64±0.01</td><td>13.64±0.01</td><td>0.47±0.02</td><td>1.02±0.02</td><td>11.78±0.07</td><td>0.64±0.01</td></tr><tr><td>EGNNReg</td><td>13.82±0.19</td><td>61.68±0.37</td><td>6.06±0.01</td><td>13.49±0.06</td><td>0.63±0.01</td><td>1.68±0.01</td><td>11.05±0.01</td><td>0.66±0.01</td></tr><tr><td>GMN</td><td>10.14±0.03</td><td>48.12±0.40</td><td>4.83±0.01</td><td>13.11±0.03</td><td>0.40±0.01</td><td>0.91±0.01</td><td>10.22±0.08</td><td>0.59±0.01</td></tr><tr><td>GMN-L</td><td>9.76±0.11</td><td>54.17±0.69</td><td>4.63±0.01</td><td>12.82±0.03</td><td>0.41±0.01</td><td>0.88±0.01</td><td>10.45±0.04</td><td>0.59±0.01</td></tr></table>
+
+MD17. We adopt MD17 (Chmiela et al., 2017) which involves the trajectories of eight molecules generated via molecular dynamics simulation. Our goal here is to predict the future positions of the atoms given the current system state. We observe that the lengths of chemical bonds remain very stable during the simulation, making it reasonable to model the bonds as sticks. The complete implementation details are deferred to Appendix E. As presented in Table 4, GMN outperforms other competitive equivariant models on 7 of the 8 molecules. Particularly, on molecules with complex structures (e.g., Aspirin, Benzene, and Salicylic), the improvement of GMN is more significant, showcasing the benefit of constraint modeling on the bonds. Yet, we also observe that the constraint-aware models (GMN and EGNNReg) perform worse than others on Ethanol, possibly because Ethanol is a relatively small molecule with simple structure, where considering the bond constraints possibly makes less benefit but instead hinders the learning. Surprisingly, GMN-L showcases very competitive performance on this dataset. It surpasses GMN on 4 of the 8 molecules, exhibiting that learnable FK works in practice even it does not involve domain knowledge of the constraint into kinematics modeling.
+
+![](images/1b1108a737bda092bc631cb1c1f435e0fd50355bbecb8d33870543feb68f59c2.jpg)  
+Figure 5: Molecules in MD17.
+
+CMU Motion Capture. We use the motion data from the CMU Motion Capture Database (CMU, 2003), which contains the trajectory of human motion in various scenarios. Different parts of the human body could be treated as hard rigid-body constraints. We focus on the walking motion of single object (subject $\# 3 5$ ) containing 23 trials, similar to Kipf et al. (2018). As depicted in Table 5, GMN outperforms other models by a large margin, verifying the efficacy of our equivariant constraint module on modeling complex rigid bodies. We further provide a visualization in Fig. 6, where GMN predicts the motion accurately while EGNN yields larger error. Again, GMN-L, although is inferior to GMN, is better than other methods remarkably.
+
+Table 5: Prediction error $( \times 1 0 ^ { - 2 } )$ on motion capture. Results averaged across 3 runs.
+
+<table><tr><td>GNN</td><td>TFN</td><td>SE(3)-Tr.</td><td>RF</td><td>EGNN</td><td>EGNNReg</td><td>GMN</td><td>GMN-L</td></tr><tr><td>67.3±1.1</td><td>66.9±2.7</td><td>60.9±0.9</td><td>197.0±1.0</td><td>59.1±2.1</td><td>59.5±2.2</td><td>43.9±1.1</td><td>50.9±0.7</td></tr></table>
+
+![](images/8844d0ea1eaa1247993ee084bec27b9928775921c40a3df90d72928af55db814.jpg)  
+Figure 6: Left to Right: initial position, GMN, EGNN (all in blue). Ground truths are in red.
+
+# 5 CONCLUSION
+
+In this paper, we propose Graph Mechanics Networks (GMN) that are capable of characterising constrained systems of interacting objects. The core is making use of generalized coordinates, by which the constraints are implicitly and exactly encapsulated in the forward kinematics. To enable Euclidean symmetry, we have developed a general form of equivariant functions to simulate the interaction forces and backward dynamics, whose expressivity is theoretically justified. For the simulated systems with particles, sticks and hinges, GMN outperforms existing methods regarding prediction error, constraint satisfaction and data efficiency. Moreover, the evaluations on two realworld datasets support the generalization ability of GMN towards complex systems.
+
+# 6 REPRODUCIBILITY STATEMENT
+
+The complete proof of the theorems is provided in Appendix A. The hyper-parameters and other experimental details are provided in Appendix E.
+
+Our code is available at: https://github.com/hanjq17/GMN.
+
+# 7 ETHICS STATEMENT
+
+The research in this paper does NOT involve any human subject, and our dataset is not related to any issue of privacy and can be used publicly. All authors of this paper follow the ICLR Code of Ethics (https://iclr.cc/public/CodeOfEthics).
+
+# ACKNOWLEDGMENTS
+
+This work was jointly supported by the following projects: the Scientific Innovation 2030 Major Project for New Generation of AI under Grant NO. 2020AAA0107300, Ministry of Science and Technology of the People’s Republic of China; the National Natural Science Foundation of China (No.62006137); Tencent AI Lab Rhino-Bird Visiting Scholars Program (VS2022TEG001); Beijing Academy of Artificial Intelligence (BAAI).
+
+# REFERENCES
+
+Peter W Battaglia, Razvan Pascanu, Matthew Lai, Danilo Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. arXiv preprint arXiv:1612.00222, 2016.
+
+Stefan Chmiela, Alexandre Tkatchenko, Huziel E Sauceda, Igor Poltavsky, Kristof T Schutt, and ¨ Klaus-Robert Muller. Machine learning of accurate energy-conserving molecular force fields. ¨ Science advances, 3(5):e1603015, 2017.
+
+CMU. Carnegie-mellon motion capture database. 2003. URL http://mocap.cs.cmu.edu.
+
+George Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of control, signals and systems, 2(4):303–314, 1989.
+
+Mingyu Ding, Zhenfang Chen, Tao Du, Ping Luo, Josh Tenenbaum, and Chuang Gan. Dynamic visual reasoning by learning differentiable physics models from video and language. NeurIPS, 34, 2021.
+
+Marc Finzi, Samuel Stanton, Pavel Izmailov, and Andrew Gordon Wilson. Generalizing convolutional neural networks for equivariance to lie groups on arbitrary continuous data. In International Conference on Machine Learning, pp. 3165–3176. PMLR, 2020a.
+
+Marc Finzi, Ke Alexander Wang, and Andrew Gordon Wilson. Simplifying hamiltonian and lagrangian neural networks via explicit constraints. arXiv preprint arXiv:2010.13581, 2020b.
+
+Fabian B Fuchs, Daniel E Worrall, Volker Fischer, and Max Welling. Se (3)-transformers: 3d rototranslation equivariant attention networks. arXiv preprint arXiv:2006.10503, 2020.
+
+Chuang Gan, Jeremy Schwartz, Seth Alter, Martin Schrimpf, James Traer, Julian De Freitas, Jonas Kubilius, Abhishek Bhandwaldar, Nick Haber, Megumi Sano, et al. Threedworld: A platform for interactive multi-modal physical simulation. NeurIPS, 2021.
+
+Kurt Hornik. Approximation capabilities of multilayer feedforward networks. Neural networks, 4 (2):251–257, 1991.
+
+Michael J Hutchinson, Charline Le Lan, Sheheryar Zaidi, Emilien Dupont, Yee Whye Teh, and Hyunjik Kim. Lietransformer: equivariant self-attention for lie groups. In International Conference on Machine Learning, pp. 4533–4543. PMLR, 2021.
+
+Thomas Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard Zemel. Neural relational inference for interacting systems. arXiv preprint arXiv:1802.04687, 2018.
+
+Jonas Kohler, Leon Klein, and Frank No ¨ e. Equivariant flows: sampling configurations for multi-´ body systems with symmetric energies. arXiv preprint arXiv:1910.00753, 2019.
+
+Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. arXiv preprint arXiv:1810.01566, 2018.
+
+Michael Lutter, Christian Ritter, and Jan Peters. Deep lagrangian networks: Using physics as model prior for deep learning. arXiv preprint arXiv:1907.04490, 2019.
+
+Karolis Martinkus, Aurelien Lucchi, and Nathanael Perraudin. Scalable graph networks for particle ¨ simulations. AAAI, 2021.
+
+RV Mises and Hilda Pollaczek-Geiringer. Praktische verfahren der gleichungsauflosung. ¨ ZAMMJournal of Applied Mathematics and Mechanics/Zeitschrift fur Angewandte Mathematik und ¨ Mechanik, 9(1):58–77, 1929.
+
+Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li Fei-Fei, Joshua B Tenenbaum, and Daniel LK Yamins. Flexible neural representation for physics prediction. arXiv preprint arXiv:1806.08047, 2018.
+
+Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W Battaglia. Learning meshbased simulation with graph networks. arXiv preprint arXiv:2010.03409, 2020.
+
+Alvaro Sanchez-Gonzalez, Victor Bapst, Kyle Cranmer, and Peter Battaglia. Hamiltonian graph networks with ode integrators. arXiv preprint arXiv:1909.12790, 2019.
+
+Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. Learning to simulate complex physics with graph networks. In International Conference on Machine Learning, pp. 8459–8468. PMLR, 2020.
+
+Victor Garcia Satorras, Emiel Hoogeboom, and Max Welling. E(n) equivariant graph neural networks. arXiv preprint arXiv:2102.09844, 2021.
+
+Chence Shi, Shitong Luo, Minkai Xu, and Jian Tang. Learning gradient fields for molecular conformation generation. arXiv preprint arXiv:2105.03902, 2021.
+
+Joshua B Tenenbaum, Charles Kemp, Thomas L Griffiths, and Noah D Goodman. How to grow a mind: Statistics, structure, and abstraction. science, 331(6022):1279–1285, 2011.
+
+Nathaniel Thomas, Tess Smidt, Steven Kearnes, Lusann Yang, Li Li, Kai Kohlhoff, and Patrick Riley. Tensor field networks: Rotation-and translation-equivariant neural networks for 3d point clouds. arXiv preprint arXiv:1802.08219, 2018.
+
+Benjamin Ummenhofer, Lukas Prantl, Nils Thuerey, and Vladlen Koltun. Lagrangian fluid simulation with continuous convolutions. In International Conference on Learning Representations, 2019.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 32(1):4–24, 2020.
+
+Shuqi Yang, Xingzhe He, and Bo Zhu. Learning physical constraints with neural projections. arXiv preprint arXiv:2006.12745, 2020.
+
+# A THE PROOF OF THEOREM 1
+
+In the following, we define the orthogonal group as $\mathcal { O } ( d ) = \{ O \in \mathbb { R } ^ { d \times d } \mid O ^ { \top } O = O O ^ { \top } = I _ { d } \}$ Prior to providing the proof for Theorem 1, we first list two necessary lemmas below.
+
+Lemma 1. For any two matrices $Z _ { 1 } , Z _ { 2 } \in \mathbb { R } ^ { d \times m }$ , we have this equivalence: $\exists O \in { \mathcal { O } } ( d ) , O Z _ { 1 } =$ ${ \cal Z } _ { 2 } \Leftrightarrow { \cal Z } _ { 1 } ^ { \top } { \cal Z } _ { 1 } = \dot { \cal Z } _ { 2 } ^ { \top } { \cal Z } _ { 2 }$ .
+
+Proof. We only need to prove the $" \Leftarrow 2 ^ { , 3 }$ direction, as $\ " \Rightarrow \ "$ holds clearly. Suppose the SVD decomposition of $Z _ { 1 }$ as $Z _ { 1 } , \bar { = } \ U _ { 1 } S _ { 1 } V _ { 1 } ^ { \top }$ with the left-singular matrix $U _ { 1 } \in { \mathcal { O } } ( d )$ , the singular diagonal matrix $S _ { 1 } ~ \in ~ \mathbb { R } ^ { d \times m }$ , and the right-singular matrix $V _ { 1 } ~ \in ~ { \mathcal { O } } ( m )$ . Since $Z _ { 1 } ^ { \top } Z _ { 1 } \ = \ Z _ { 2 } ^ { \top } \bar { Z _ { 2 } }$ , then there must exists a certain SVD decomposition of $Z _ { 2 }$ that shares the same singular matrix and right-singular matrix with $Z _ { 1 }$ , implying that $Z _ { \mathrm { 2 } } ~ = ~ U _ { \mathrm { 2 } } S _ { \mathrm { 1 } } V _ { \mathrm { 1 } } ^ { \top }$ , where $U _ { \mathrm { 2 } } ~ \in ~ \mathcal { O } \bar { ( d ) }$ . Hence, $\begin{array} { r } { \pmb { Z } _ { 2 } = \mathbf { \bar { U } } _ { 2 } \pmb { S } _ { 1 } \bar { \mathbf { V } } _ { 1 } ^ { \top } = U _ { 2 } \pmb { U } _ { 1 } ^ { \top } \pmb { U } _ { 1 } \pmb { S } _ { 1 } \pmb { V } _ { 1 } ^ { \top } = \mathbf { \bar { U } } _ { 2 } \pmb { \bar { U } } _ { 1 } ^ { \top } \pmb { Z } _ { 1 } } \end{array}$ , which concludes the proof owing to the orthogonality of $U _ { 2 } \pmb { U } _ { 1 } ^ { \top }$ . □
+
+Lemma 2. The function $f : \mathbb { R } ^ { d \times m }  \mathbb { R } ^ { m ^ { \prime } }$ is invariant on $\mathcal O ( d )$ , namely, $f ( O Z ) = f ( Z ) , \forall O \in$ $\mathcal { O } ( d ) , \forall Z \in \mathbb { R } ^ { d \times m }$ , if and only if there exists function $g : \mathbb { R } ^ { m \times m }  \mathbb { R } ^ { m ^ { \prime } }$ satisfying $f ( Z ) =$ $g ( \boldsymbol { Z } ^ { \intercal } \boldsymbol { Z } )$ .
+
+Proof. The sufficiency is obvious. We now prove the necessity. We define the equivalence class $[ Z _ { 0 } ] \ : = \ : \{ Z \ : \ : | \ : \exists O \in { \mathcal { O } } ( d ) , O Z = Z _ { 0 } \}$ . Since $f$ is invariant to the orthogonal transformation, it means $f$ is actually a function on the equivalence class, i.e., $f ( Z ) = \bar { f } ( [ Z ] )$ . On the other hand, according to Lemma 1, we have $[ \pmb { Z } _ { 1 } ] _ { - } ^ { \circ } = [ \pmb { Z } _ { 2 } ] \Leftrightarrow \pmb { Z } _ { 1 } ^ { \top } \pmb { Z } _ { 1 } = \pmb { \overset { . } { Z } } _ { 2 } ^ { \top } \pmb { Z } _ { 2 }$ , which implies the oneto-one correspondence between $[ Z ]$ and $Z ^ { \top } Z$ ; hence, there must exist a function $f ^ { \prime }$ leading to $[ Z ] = f ^ { \prime } ( Z ^ { \dagger } Z )$ , and $f ^ { \prime }$ is continuous in terms of any invariant metric such as the norm $\| Z ^ { \top } Z \|$ . Overall, $f ( Z ) = f ( [ Z ] ) = f ( f ^ { \prime } ( Z ^ { \top } Z ) ) : = g ( Z ^ { \top } Z )$ . □
+
+We are now ready to prove Theorem 1 that is copied below for better readability.
+
+Theorem 1. If $m \geq d$ and the row rank of $z$ is full, i.e. $r a n k ( Z ) = d ,$ , then for any continuous orthogonality-equivariant function ${ \hat { \varphi } } ( Z , h )$ , there must exist an MLP $\sigma _ { w }$ satisfying $\parallel \varphi ( \boldsymbol { Z } , h ) \mathrm { ~ - ~ }$ $\hat { \varphi } ( Z , h ) \rVert < \epsilon$ for arbitrarily small error .
+
+Proof. Without loss of generality, we will omit the non-vector term $h$ , which does not change the story but let our proof more concise. Because $z$ is of full row-rank, the columns of an arbitrary function $\hat { \varphi } ( Z )$ can be represented as a linear combination of the columns of $z$ ; in other words, there must exist a function $\pi : \mathbb { R } ^ { d \times m }  \mathbb { R } ^ { m \times m ^ { \prime } }$ giving rise to $\hat { \varphi } ( Z ) = Z \pi ( Z )$ . Considering the orthogonality-equivariance, we derive the property of $\pi ( Z )$ as:
+
+$$
+\begin{array} { r l } & { ~ \hat { \varphi } ( O Z ) = O \hat { \varphi } ( Z ) , } \\ & { \Rightarrow O Z \pi ( O Z ) = O Z \pi ( Z ) , } \\ & { ~ \Rightarrow Z \pi ( O Z ) = Z \pi ( Z ) . } \end{array}
+$$
+
+Since $d \leq m$ and the row-rank of $z$ is full, we perform the compact SVD decomposition on $z$ , namely, ${ \cal Z } = U _ { \cal Z } S _ { \cal Z } V _ { \cal Z } ^ { \top }$ , where $U _ { Z } \in \mathcal { O } ( d ) , \ : \dot { \mathbb { R } } ^ { d \times d } \ni S _ { Z } \textgreater \dot { 0 }$ , and $V _ { Z } \in \mathbb { R } ^ { \hat { m } \times d }$ satisfying $V _ { Z } ^ { \top } V _ { Z } = I _ { d }$ . Eq. 14 becomes:
+
+$$
+Z \pi ( O Z ) = Z \pi ( Z ) ,
+$$$$
+\begin{array} { c } { { { \cal Z } \pi ( { \cal U } Z ) = { \cal Z } \pi ( Z ) , } } \\ { { \Rightarrow U _ { Z } S _ { Z } V _ { Z } ^ { \top } \pi ( { \cal O } Z ) = U _ { Z } S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) , } } \\ { { \Rightarrow S _ { Z } V _ { Z } ^ { \top } \pi ( { \cal O } Z ) = S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) . } } \end{array}
+$$
+
+Given that $\begin{array} { r } { S _ { Z } = \mathrm { E i g e n } ( Z ^ { \top } Z ) } \end{array}$ and $V _ { Z } = \mathrm { E i g e n V e c t o r } ( Z ^ { \top } Z )$ are respectively the eigenvalues and eigenvectors of $\bar { Z } ^ { \top } \dot { Z }$ and are clearly invariant to the orthogonal transformation of $z$ . Their values can be numerically approximated by iterative programs, such as the power method (Mises & Pollaczek-Geiringer, 1929), thus can be treated as the continuous functions of $Z ^ { \top } Z$ . Let us define $g ^ { \prime } ( Z ) : = S _ { Z } V _ { Z } ^ { \top } \pi ( Z )$ . Then, we keep deriving Eq. 15 by:
+
+$$
+\begin{array} { r l } & { ~ S _ { Z } V _ { Z } ^ { \top } \pi ( O Z ) = S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) , } \\ & { \Rightarrow S _ { O Z } V _ { O Z } ^ { \top } \pi ( O Z ) = S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) , } \\ & { ~ \Rightarrow g ^ { \prime } ( O Z ) = g ^ { \prime } ( Z ) . } \end{array}
+$$
+
+According to Lemma 2, the function $g$ satisfies Eq. 16 if and only if it is written as $g ^ { \prime } ( Z ) = g ( Z ^ { \top } Z )$ for a certain function $g$ . By checking the formulation of $\hat { \varphi } ( Z )$ as demonstrated before, we arrive at
+
+$$
+\begin{array} { r l } & { \hat { \varphi } ( Z ) = Z \pi ( Z ) , } \\ & { \quad \quad \quad = U _ { Z } S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) , } \\ & { \quad \quad \quad = U _ { Z } g ^ { \prime } ( Z ) , } \\ & { \quad \quad \quad = U _ { Z } g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad = U _ { Z } S _ { Z } V _ { Z } ^ { \top } V _ { Z } S _ { Z } ^ { - 1 } g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad = Z V _ { Z } S _ { Z } ^ { - 1 } g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad : = Z \eta ( Z ^ { \top } Z ) . } \end{array}
+$$
+
+Here the function $\eta$ can be approximated by MLP whose universality has been justified by (Cybenko, 1989; Hornik, 1991). The conclusion of Theorem 1 is proved.
+
+Corollary 1. Assume $m \geq d$ , and also the entries of $z$ are drawn independently from a distribution that is absolutely continuous with respect to the Lebesgue measure in $\mathbb { R }$ . Then, almost surely, the conclusion of Theorem 1 holds.
+
+Proof. This is straightforward. When $\operatorname { r a n k } ( Z ) < d$ , the columns of $z$ are located in a subspace of $\mathbb { R } ^ { d }$ (for example a line or a plane in the 3D space), whose measure is zero. Therefore, the probability for making rank $\mathbf { \nabla } ( Z ) = d$ is 1, and we almost surely have the same conclusion as Theorem 1. □
+
+Corollary 2. For any continuous orthogonality-equivariant function ${ \hat { \varphi } } ( Z , h )$ whose output is located in the linear subspace expanded by the columns of $z$ , the conclusion of Theorem $^ { l }$ holds universally.
+
+Proof. According to the definition of $\hat { \varphi } ( Z )$ , we still obtain $\hat { \varphi } ( Z ) = Z \pi ( Z )$ . Let us assume $d > m$ (otherwise we can directly obtain Theorem 1), then the full SVD decomposition of $z$ is $z =$ $\bar { U } _ { Z } S _ { Z } V _ { Z } ^ { \top }$ , with $U _ { Z } \in { \mathcal { O } } ( d )$ , $S _ { Z } \in \mathbb { R } ^ { d \times m }$ , and $V _ { Z } \in { \mathcal { O } } ( m )$ . But here, $S _ { Z }$ is not strictly positive. Suppose $S _ { Z } = \left( { \cal S } _ { + } \right)$ , where $S _ { + } > 0$ . We retain that $S _ { Z } V _ { Z } ^ { \top } \pi ( Z ) = g ( Z ^ { \top } Z )$ by imitating the proof in Eq. 14-16. Analogous to Eq. 17, we derive,
+
+$$
+\begin{array} { r l } & { \hat { \varphi } ( Z ) = Z \pi ( Z ) , } \\ & { \quad \quad \quad = U _ { Z } g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad = U _ { Z } S _ { Z } V _ { Z } ^ { \top } V _ { Z } \left( S _ { + } ^ { - 1 } , \mathbf { 0 } \right) g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad = Z V _ { Z } \left( S _ { + } ^ { - 1 } , \mathbf { 0 } \right) g ( Z ^ { \top } Z ) , } \\ & { \quad \quad \quad : \quad = Z \eta ( Z ^ { \top } Z ) , } \end{array}
+$$
+
+which concludes the proof.
+
+# B THE DYNAMICS ANALYSES FOR STICKS AND HINGES
+
+The analytical forms of the dynamics for sticks and hinges can be found from a mechanics book. Here we derive the formulas on our own to make our paper more self-contained. For simplicity, we consider all particles to be of the equal mass and the sticks of no mass.
+
+Dynamics analysis of sticks. In Fig. 7 (Left), we assume the forces acting on particles 1 and 2 are separately $f _ { 1 }$ and $f _ { 2 }$ . By following the theorem of the motion of the center of mass, the acceleration of the center is given by
+
+$$
+\ddot { \pmb q } _ { 0 } = \frac { { \pmb f } _ { 1 } + { \pmb f } _ { 2 } } { m } .
+$$
+
+![](images/4b09edecb8cea29e5ebbd35373f0a23ca72262e0cd25438aa03ce6be383193bc.jpg)  
+Figure 7: Left: Dynamics of sticks. Right: Dynamics of hinges.
+
+The rotation accelerations of particles 1 and 2 around the center are calculated by
+
+$$
+\ddot { \pmb { \theta } } _ { 0 1 } = \ddot { \pmb { \theta } } _ { 0 2 } = \frac { \pmb { M } } { J } = \frac { \pmb { x } _ { 0 1 } \times \pmb { f } _ { 1 } + \pmb { x } _ { 0 2 } \times \pmb { f } _ { 2 } } { m \| \pmb { x } _ { 0 1 } \| ^ { 2 } + m \| \pmb { x } _ { 0 2 } \| ^ { 2 } } ,
+$$
+
+where $M$ defines the total torque and $J$ is the moments of inertia.
+
+Dynamics analysis of hinges. The analysis for hinges is more complicated than sticks. In Fig. 7 (Right), the forces on particles $0 , 1$ and 2 are $f _ { 0 } , f _ { 1 }$ and $f _ { 2 }$ . By using Newton’s second law,
+
+$$
+{ \pmb a } _ { 0 } + { \pmb a } _ { 1 } + { \pmb a } _ { 2 } = \frac { { \pmb f } } { m } ,
+$$
+
+where the aggregated force is $\pmb { f } = \pmb { f } _ { 0 } + \pmb { f } _ { 1 } + \pmb { f } _ { 2 }$ . In addition, the kinematics relations between the three particles show that
+
+$$
+\begin{array} { r } { \pmb { a } _ { 1 } = \pmb { a } _ { 0 } + \ddot { \pmb { \theta } } _ { 0 1 } \times \pmb { x } _ { 0 1 } + \dot { \pmb { \theta } } _ { 0 1 } \times \pmb { \nu } _ { \mathbf { 0 1 } } , } \\ { \pmb { a } _ { 2 } = \pmb { a } _ { 0 } + \ddot { \pmb { \theta } } _ { 0 2 } \times \pmb { x } _ { 0 2 } + \dot { \pmb { \theta } } _ { 0 2 } \times \pmb { \nu } _ { \mathbf { 0 2 } } , } \end{array}
+$$
+
+where $\dot { \pmb \theta } _ { 0 1 }$ and $\ddot { \theta } _ { 0 1 }$ denote the speed and acceleration of the rotation angle of particle 1 around 0, and $\nu _ { 0 1 }$ is the corresponding linear velocity; the symbols $\dot { \theta } _ { 0 2 } , \ddot { \theta } _ { 0 2 }$ and $\nu _ { 0 2 }$ are defined similarly. Moreover, the relative rotation acceleration of particle 1 to 0 is caused by the external force $f _ { 1 }$ and the inertia force $- m a _ { 0 }$ acting on 1, which derives that
+
+$$
+{ \ddot { \pmb { \theta } } } _ { 0 1 } = { \frac { M _ { 0 1 } } { J _ { 0 1 } } } = { \frac { { \pmb x } _ { 0 1 } \times ( { \pmb f } _ { 1 } - m { \pmb a } _ { 0 } ) } { m \| { \pmb x } _ { 0 1 } \| ^ { 2 } } } .
+$$
+
+Analogously,
+
+$$
+\ddot { \pmb { \theta } } _ { 0 2 } = \frac { M _ { 0 2 } } { J _ { 0 2 } } = \frac { \pmb { x } _ { 0 2 } \times ( \pmb { f } _ { 2 } - m \pmb { a } _ { 0 } ) } { m \| \pmb { x } _ { 0 2 } \| ^ { 2 } } .
+$$
+
+After substituting Eq. 24 into Eq. 22, and Eq. 25 into Eq. 23, and then rearranging Eq. 21, we have
+
+$$
+\pmb { a } _ { 0 } = ( \pmb { I } + \pmb { e } _ { 0 1 } \pmb { e } _ { 0 1 } ^ { \top } + \pmb { e } _ { 0 2 } \pmb { e } _ { 0 2 } ^ { \top } ) ^ { - 1 } \pmb { a } ,
+$$
+
+where repres $\begin{array} { r } { a = \frac { f } { m } - \dot { \theta } _ { 0 1 } \times \nu _ { 0 1 } - \dot { \theta } _ { 0 2 } \times \nu _ { 0 2 } - \left( I - e _ { 0 1 } e _ { 0 1 } ^ { \top } \right) \frac { f _ { 1 } } { m } - \left( I - e _ { 0 2 } e _ { 0 2 } ^ { \top } \right) \frac { f _ { 2 } } { m } } \end{array}$ with ck to $e _ { 0 1 }$ and plify $e _ { 0 2 }$ ${ \pmb x } _ { 0 1 }$ $\scriptstyle { \pmb x } _ { 0 2 }$   
+derivation by observing $\begin{array} { r } { \frac { \pmb { x } _ { 0 1 } \times \pmb { f } _ { 1 } \times \pmb { x } _ { 0 1 } } { \| \pmb { x } _ { 0 1 } \| ^ { 2 } } = ( \pmb { I } - \pmb { e } _ { 0 1 } \pmb { e } _ { 0 1 } ^ { \top } ) \pmb { f } _ { 1 } } \end{array}$ . Besides, $\pmb { I } + e _ { 0 1 } \pmb { e } _ { 0 1 } ^ { \top } + e _ { 0 2 } \pmb { e } _ { 0 2 } ^ { \top }$ is invertible,   
+hence Eq. 26 is always meaningful.
+
+Substituting Eq. 26 back into Eq. 24 and Eq. 25 derives the values of $\ddot { \pmb \theta } _ { 0 1 }$ and $\ddot { \theta } _ { 0 2 }$ . Note that in $\ S 3 . 3$ , we employ the denotation of generalized coordinates by $q _ { 0 } , \dot { q } _ { 0 }$ and $\ddot { q } _ { \mathrm { 0 } }$ which indeed share the same meaning with the Cartesian coordinates ${ \bf { \mathcal { x } } } _ { 0 } , { \pmb { v } } _ { 0 }$ and $\mathbf { \delta a } _ { 0 }$ of particle 0.
+
+# C KINEMATICS DECOMPOSITION
+
+We manually build the forward kinematics (Eq. 9) of the stick (and hinge), which relies on the domain knowledge of the underlying physics. However, for complex systems, we no longer require to derive the kinematics of the entire system. Instead, we propose kinematics decomposition, a simple yet effective trick that can decompose each input system (an arbitrary graph) into particles and sticks. Taking the MD17 dataset as an example, for each molecule, we select certain bonds as sticks (the circles in Fig. 5) and the remaining atoms as isolated particles; in this way, we obtain a set of particles and sticks. Note that different sticks are not allowed to intersect; otherwise, it will generate two values for the intersecting particle of two sticks and cause ambiguity if these two values are distinct. Although this kind of kinematics decomposition will only maintain partial constraints, it greatly enlarges the application scope of our current formulation Eq. (5-9) without any revision. More importantly, our experiments verify that GMN by this formulation is sufficient to surpass other methods on complex systems like molecules. On CMU Motion Capture, since the motion graph contains no circle and is of the tree-like structure, it is tractable to derive the exact forward kinematics by recursive kinematics computation from the root node. Yet, we still encourage the usage of the above kinematics decomposition for its easy implementation and compatibility with our GMN.
+
+Table 6: Prediction error $( \times 1 0 ^ { - 2 } )$ on various types of systems. The first column “ ${ \bf \dot { p } } , s , h ^ { \prime \prime }$ denotes the scenario with p isolated particles, s sticks and h hinges. Models are trained with 500 samples.   
+
+<table><tr><td></td><td>GMN</td><td>EGNN</td><td>EGNNReg</td><td>GNN</td><td>TFN</td><td>SE(3)-Tr.</td><td>RF</td><td>Linear</td></tr><tr><td>1,2,0</td><td>1.84</td><td>2.81</td><td>2.94</td><td>5.33</td><td>11.54</td><td>5.54</td><td>3.50</td><td>8.23</td></tr><tr><td>2,0,1</td><td>2.02</td><td>2.27</td><td>2.66</td><td>5.01</td><td>9.87</td><td>5.14</td><td>3.07</td><td>7.55</td></tr><tr><td>2,4,0</td><td>2.34</td><td>3.59</td><td>3.87</td><td>8.05</td><td>11.30</td><td>9.22</td><td>5.37</td><td>10.10</td></tr><tr><td>0,5,0</td><td>2.54</td><td>4.13</td><td>4.29</td><td>8.63</td><td>11.92</td><td>9.83</td><td>5.94</td><td>10.48</td></tr><tr><td>7,0,1</td><td>2.39</td><td>2.66</td><td>3.41</td><td>7.05</td><td>10.67</td><td>8.38</td><td>4.66</td><td>9.71</td></tr><tr><td>1,0,3</td><td>3.21</td><td>4.56</td><td>5.14</td><td>8.32</td><td>11.62</td><td>9.57</td><td>5.91</td><td>9.90</td></tr><tr><td>3,2,1</td><td>2.48</td><td>4.67</td><td>7.01</td><td>7.58</td><td>11.66</td><td>8.95</td><td>5.25</td><td>9.76</td></tr><tr><td>4,8,0</td><td>3.69</td><td>4.79</td><td>7.09</td><td>9.65</td><td>12.05</td><td>11.21</td><td>7.59</td><td>11.45</td></tr><tr><td>0,10,0</td><td>2.92</td><td>4.75</td><td>5.03</td><td>9.83</td><td>13.43</td><td>11.42</td><td>7.59</td><td>11.36</td></tr><tr><td>8,0,4</td><td>3.37</td><td>4.17</td><td>5.32</td><td>9.49</td><td>11.72</td><td>11.12</td><td>7.51</td><td>11.44</td></tr><tr><td>2,0,6</td><td>4.06</td><td>5.06</td><td>5.58</td><td>10.13</td><td>12.13</td><td>11.74</td><td>8.15</td><td>11.61</td></tr><tr><td>5,3,3</td><td>4.08</td><td>4.59</td><td>6.31</td><td>9.77</td><td>12.23</td><td>11.59</td><td>7.73</td><td>11.62</td></tr></table>
+
+# D FULL ALGORITHMIC DETAILS
+
+In the main body of the paper, for better readability, we first introduce the general pipeline of our method in $\ S \ 3 . 1$ and then present the implementation details by taking the angels into account in $\ S \ 3 . 3$ . Here, we combine them into one singe algorithmic flowchart in Alg. 1.
+
+# E MORE EXPERIMENTAL DETAILS AND RESULTS
+
+Hyper-parameters and baselines. For GNN, RF, EGNN, EGNNReg, and GMN, we empirically find that the following hyper-parameters generally work well, and use them across all experimental evaluations: batch size 200, Adam optimizer with learning rate 0.0005, hidden dim 64, and weight decay $1 \times 1 0 ^ { - 1 0 }$ . All models are evaluated with four layers. SE(3)-Transformer and TFN do not perform well on our datasets, potentially due to the challenge of highly complex and constrained systems. Consequently, we tune the hyper-parameters and adopt the following configuration: batch size 100, learning rate 0.001, hidden $\mathrm { d i m } 6 4$ , representation degrees 3 and weight decay $1 \times 1 0 ^ { - 8 }$ . Models are trained for 600 epochs on the simulation dataset, and 500 epochs on the real-world datasets. EGNNReg is a variant of EGNN that explicitly adds the constraint error into its training loss by a regularization factor of $\lambda$ . In our experiments, we also treat $\lambda$ as a hyper-parameter, and choose $\lambda$ that yields the best performance within the range [0.01, 0.1].
+
+Detailed experimental setup on MD17. We randomly split the dataset into train/validation/test sets containing 500/2000/2000 frame pairs respectively. We choose $T = 5 0 0 0$ as the span between the input and prediction frames, and the difference in positions as the input velocity. The hyper
+
+# Algorithm 1 Graph Mechanics Networks (GMNs)
+
+Input: Initial states of all particles $\{ S _ { i } ^ { 0 } = ( \pmb { x } _ { i } ^ { 0 } , \pmb { v } _ { i } ^ { 0 } ) \} _ { i = 1 } ^ { N }$ and features $\{ h _ { i } ^ { 0 } \} _ { i } ^ { N }$ ; Learnable equivariant functions $\varphi _ { 1 } , \varphi _ { 2 } , \psi , \psi ^ { \prime }$ ; Layer number $L$ .
+
+Compute the generalized coordinates of all structural objects $\{ ( \pmb q _ { k } ^ { 0 } , \dot { \pmb q } _ { k } ^ { 0 } , \{ \dot { \pmb \theta } _ { k i } ^ { 0 } \} _ { i \in \mathcal { O } _ { k } } ) \} _ { k = 1 } ^ { K }$ . for layer $l = 1$ to $L$ do
+
+for particle $i = 1$ to $N$ do
+
+Calculate the interaction force $\mathbf { \mathcal { f } } _ { i } ^ { l }$ and feature $h _ { i } ^ { l }$ for each particle by:
+
+$$
+\pmb { f } _ { i } ^ { l } , h _ { i } ^ { l } = \sum _ { j = 1 } ^ { N } \varphi _ { 1 } ( \pmb { x } _ { j i } ^ { l - 1 } , h _ { i } ^ { l - 1 } , h _ { j } ^ { l - 1 } , e _ { j i } ) .
+$$
+
+# end for
+
+for object $k = 1$ to $K$ do
+
+Inference the generalized Cartesian acceleration $\ddot { \pmb q } _ { k } ^ { l }$ via:
+
+$$
+\begin{array} { r l } & { \ddot { \pmb q } _ { k } ^ { l } = \displaystyle \sum _ { i \in \mathcal { O } _ { k } } \varphi _ { 2 } ( { \pmb f } _ { i } ^ { l } ) , \quad \mathrm { ( f o r ~ s t i c k s ) } } \\ & { \ddot { \pmb q } _ { k } ^ { l } = \displaystyle \sum _ { i \in \mathcal { O } _ { k } } \varphi _ { 2 } ( { \pmb f } _ { i } ^ { l } , { \pmb x } _ { k i } ^ { l - 1 } , { \pmb v } _ { k i } ^ { l - 1 } ) . \quad \mathrm { ( f o r ~ h i n g e s ) } } \end{array}
+$$
+
+Derive the generalized angle acceleration:
+
+$$
+\begin{array} { r l } & { \ddot { \pmb { \theta } } _ { k i } = \cfrac { \sum _ { i \in \mathcal { O } _ { k } } \pmb { x } _ { k i } \times \pmb { f } _ { i } } { \sum _ { i \in \mathcal { O } _ { k } } \| \pmb { x } _ { k i } \| ^ { 2 } } , \forall i \in \mathcal { O } _ { k } , \quad \mathrm { ( f o r ~ s t i c k s ) } } \\ & { \ddot { \pmb { \theta } } _ { k i } = \cfrac { \pmb { x } _ { k i } \times ( \pmb { f } _ { i } - \ddot { \pmb { q } } _ { k } ) } { \| \pmb { x } _ { k i } \| ^ { 2 } } , \forall i \in \mathcal { O } _ { k } . \quad \mathrm { ( f o r ~ h i n g e s ) } } \end{array}
+$$
+
+Update the positions and velocities as follows:
+
+$$
+\begin{array} { r l } & { \displaystyle \dot { q } _ { k } ^ { l } = \psi \big ( \sum _ { i \in \mathcal { O } _ { k } } h _ { i } ^ { l - 1 } \big ) \dot { q } _ { k } ^ { l - 1 } + \ddot { q } _ { k } ^ { l } , } \\ & { \displaystyle q _ { k } ^ { l } = q _ { k } ^ { l - 1 } + \dot { q } _ { k } ^ { l } , } \\ & { \displaystyle \dot { \theta } _ { k i } ^ { l } = \psi ^ { \prime } \big ( \sum _ { i \in \mathcal { O } _ { k } } h _ { i } ^ { l - 1 } \big ) \dot { \theta } _ { k i } ^ { l - 1 } + \ddot { \theta } _ { k i } ^ { l } , \forall i \in \mathcal { O } _ { k } . } \end{array}
+$$
+
+Perform the forward kinematics for each particle in $\mathcal { O } _ { k }$ :
+
+$$
+\begin{array} { r l } & { \pmb { x } _ { i } ^ { l } = \pmb { q } _ { k } ^ { l } + \mathrm { r o t } ( \dot { \pmb { \theta } } _ { k i } ^ { l } ) \pmb { x } _ { k i } ^ { l - 1 } , \forall i \in \mathcal { O } _ { k } , } \\ & { \pmb { v } _ { i } ^ { l } = \dot { \pmb { q } } _ { k } ^ { l } + \dot { \pmb { \theta } } _ { k i } ^ { l } \times \pmb { x } _ { k i } ^ { l } , \forall i \in \mathcal { O } _ { k } . } \end{array}
+$$
+
+end for
+
+Output: The predicted states of all particles $\{ S _ { i } ^ { L } \} _ { i = 1 } ^ { N }$ parameters of all models are kept the same as the synthetic dataset. We masked out the hydrogen atoms, focusing on the prediction of large atoms. We further augment the original molecular graph with 2-hop neighbors, and concatenate the hop index with atom numbers of the connected atoms as well as the edge type indicator as the edge feature, similar to Shi et al. (2021). We use the norm of velocity concatenated with the atom number as the node feature. We randomly select bonds without commonly-connected atoms as sticks, and the rest of atoms as isolated particles. Although by this means not all the bond lengths are preserved, our experiment does illustrate that this is a simple but effective strategy of applying GMN on complex systems like molecules.
+
+Detailed experimental setup on CMU Motion Capture. We first split the data into train/val/test sets containing 11/6/6 trials respectively. We then sample from the trials to get 200/600/600 frame pairs with $T = 3 0$ . We use the norm of velocity as node feature. We also augment the edges with 2-hop neighbors, and use the edge type indicator as edge feature. As for GMN, we sample 6 key bones of human body (as specified in Appendix C) as sticks, resulting in a system with 19 isolated particles and 6 sticks. Empirically, we select the edges connecting nodes (0, 11), (2, 3), (7, 8), (12, 13), (17, 18), and (24, 25) as sticks on the motion capture dataset, which indeed are the key parts of human body like the arms and legs.
+
+![](images/fd27a73324b65f8d7e177fd085685da9572ab13c635f85475611e0e6683b3e75.jpg)  
+Figure 8: Left: initial position(s). Middle: the prediction(s) of GMN (in blue). Right: the prediction(s) of EGNN (in blue). Ground truth is marked in red. Better viewed by zooming in.
+
+![](images/165b097d0a68ae20d62b0c944108f688b13c41eeab6b252a53d27045bce4719c.jpg)  
+Figure 9: Left: initial position (in blue). Middle: the prediction of GMN (in blue). Right: the prediction of EGNN (in blue). Ground truths are marked in red. Better viewed by zooming in.
+
+More visualizations. We visualize the prediction outcomes by GMN and EGNN in Fig. 8 on the simulation dataset. GMN is found to be able to track the ground-truth trajectories accurately, whereas EGNN yields clear position errors and particularly breaks the constraints for sticks and hinges. These results are consistent with the performance in Table 1. Fig. 9 provides extra visualization on Motion Capture. Similarly, GMN yields more accurate prediction than EGNN.
+
+More experimental results. In Table 6, we provide a comprehensive performance comparison of different models under more scenarios with 500 training samples. Clearly, GMN outperforms other models on all object combinations involved. Besides, we provide the learning curve for GMN, EGNN, and EGNNReg on the simulation dataset (3,2,1) in Fig. 10. GMN yields lower training loss and testing loss than EGNN and EGNNReg, benefiting from its constraint modeling.
+
+![](images/7a7dcb83a43fdd8c1feb9b2a9018134515d0e8fa9b6b33670dd53af3264e4016.jpg)  
+Figure 10: Learning curves on (3,2,1) with 500 training samples.
+
+# F MORE ABLATIONS
+
+Hinge treated as two sticks. We treat 0-1, 0-2 as two sticks, and apply the stick FK respectively. Afterwards, we translate the two sticks such that the 0s coincide at the midpoint of their predicted positions. From Table 7, we find that this strategy performs worse than the hinge-modeled GMN, since splitting the hinge into two sticks overlooks the kinematics at the connected point. Yet and still, it performs better than EGNN, again verifying the benefit of our proposed constraint modeling.
+
+Table 7: Ablation on hinge FK.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">|Train| = 500</td><td colspan="2">|Train| = 1500</td></tr><tr><td>3,2,1</td><td>2,0,6</td><td>5,3,3</td><td>3,2,1</td><td>2,0,6 5,3,3</td></tr><tr><td>EGNN</td><td>4.67</td><td>5.06</td><td>4.59</td><td>2.54</td><td>3.42</td></tr><tr><td>EGNNReg</td><td>7.01</td><td>5.58</td><td>6.31</td><td>2.62</td><td>3.50 3.61 3.07</td></tr><tr><td>GMN (Stick only)</td><td>3.02</td><td>4.32</td><td>4.21</td><td>2.37</td><td>3.30 2.88</td></tr><tr><td>GMN</td><td>2.48</td><td>4.06</td><td>4.08</td><td>2.10</td><td>3.22 2.86</td></tr></table>
+
+Charges as node or edge feature. In the experiment we by default assign $e _ { i j } = c _ { i } c _ { j }$ as the edge feature (denoted as “Edge $+ \textrm { C } \ '$ ). Here we instead concatenate $c _ { i }$ to the node feature of particle $i$ , and set all $e _ { i j } = 0$ (denoted as $\mathbf { \tilde { \Sigma } } ^ { \mathrm { 6 6 } } \mathbf { N o d e } + \mathbf { C } ^ { \prime }$ ). In Table 8 we observe that these alternatives on charges make very limited difference on performance, and indeed the models can learn the interaction of charges from node features, which is truly the case as depicted in Eq. 2 and 5.
+
+Table 8: Comparison of charge-assigning strategies.   
+
+<table><tr><td></td><td colspan="5">Node +C</td><td colspan="5">Edge + C</td></tr><tr><td></td><td>1,2,0</td><td>2,0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3,3</td><td>1,2.0</td><td>2,0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3,3</td></tr><tr><td>EGNN</td><td>2.89</td><td>2.28</td><td>4.25</td><td>4.80</td><td>4.50</td><td>2.81</td><td>2.27</td><td>4.67</td><td>4.75</td><td>4.59</td></tr><tr><td>EGNNReg</td><td>3.17</td><td>2.74</td><td>8.20</td><td>5.01</td><td>6.64</td><td>2.94</td><td>2.66</td><td>7.01</td><td>5.03</td><td>6.31</td></tr><tr><td>GMN</td><td>1.89</td><td>2.01</td><td>2.63</td><td>3.07</td><td>4.02</td><td>1.84</td><td>2.02</td><td>2.48</td><td>2.92</td><td>4.08</td></tr></table>
+
+# G CONSTRAINT SATISFACTION
+
+Constraint error. The constraint error is computed as the total change in the lengths of sticks and hinges between the input and output, averaged per trajectory. Specifically, for hinges, the two edges are both considered.
+
+Results. One vital feature of GMN is that it maintains the geometrical constraints exactly and inherently. To show this, Table 9 records the corresponding constraint errors of several typical models. The results do verify our claim that GMN always outputs near-zero errors (all below 1e-4). Although EGNNReg that augments EGNN with regulation helps in reducing the constraint errors, it is data-driven and limited by the number of training samples; further, the constraints are pursued softly, making it defective for the applications where hard constraints are indispensable.
+
+Table 9: Constraint error on various types of systems.   
+
+<table><tr><td></td><td colspan="5">|Train| = 500</td><td colspan="5">|Train| = 1500</td></tr><tr><td></td><td>1,2.0</td><td>2.0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3.3</td><td>1,2,0</td><td>2,0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3,3</td></tr><tr><td>GNN</td><td>0.200</td><td>0.386</td><td>0.492</td><td>0.154</td><td>0.468</td><td>0.225</td><td>0.426</td><td>0.779</td><td>0.251</td><td>0.772</td></tr><tr><td>EGNN</td><td>0.220</td><td>0.370</td><td>0.714</td><td>0.248</td><td>0.760</td><td>0.217</td><td>0.317</td><td>0.521</td><td>0.139</td><td>0.596</td></tr><tr><td>EGNNReg</td><td>0.172</td><td>0.146</td><td>0.232</td><td>0.198</td><td>0.241</td><td>0.159</td><td>0.053</td><td>0.091</td><td>0.097</td><td>0.075</td></tr><tr><td>GMN</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td></tr></table>
+
+# H MORE DISCUSSIONS ON GENERALIZATION
+
+In Table 2 we compare the generalization capability of GMN with other methods. Here, we denote GMN trained on (3,2,1) and tested across different scenarios as GMN-Transfer, and GMN trained and tested on the same dataset as GMN-Original. It is observed from Table 10 that GMN has strong generalization capability, since the transfer performance is very close to the original setting.
+
+Table 10: Comparison of GMN in the transfer and original settings.   
+
+<table><tr><td></td><td colspan="4">|Train| = 500</td><td colspan="4">|Train| = 1500</td></tr><tr><td></td><td>3,2,1</td><td>2,4,0</td><td>1,0,3</td><td>Average</td><td>3,2,1</td><td>2,4,0</td><td>1,0,3</td><td>Average</td></tr><tr><td>GMN-Transfer</td><td>2.48</td><td>2.53</td><td>3.28</td><td>2.76</td><td>2.10</td><td>2.18</td><td>2.65</td><td>2.31</td></tr><tr><td>GMN-Original</td><td>2.48</td><td>2.34</td><td>3.21</td><td>2.68</td><td>2.10</td><td>2.01</td><td>2.44</td><td>2.18</td></tr></table>
+
+# I LEARNABLE FK
+
+It is indeed instrumental to discuss whether a learnable black-box function, which requires less domain knowledge, could also yield competitive performance, and if our hand-crafted FK still shows advantage over the learnable counterpart. To answer these questions, we replace the hand-crafted part (Eq. (7-9) as well as the Euler angle computations in Sec. 3.1) with the following equations: $\bar { \pmb { v } } _ { i } ^ { l } = \phi \bar { ( } h _ { i } ^ { l - 1 } ) \pmb { v } _ { i } ^ { l - 1 } + \rho ( \ddot { \pmb { q } } _ { k } ^ { l } , \pmb { x } _ { k i } ^ { l - 1 } , \pmb { f } _ { i } ^ { l } ) , \bar { \pmb { x } } _ { i } ^ { l } = \pmb { x } _ { i } ^ { l - 1 } + \pmb { v } _ { i } ^ { l }$ , where $\rho$ is the equivariant message passing layer we propose in Sec. 3.2. By this design, the parameterized FK preserves its equivariant property (and the theoretical universality), and compared to EGNN, it additionally leverages the information from the object-level generalized coordinates $\ddot { q } _ { k } ^ { l }$ . We denote this variant of GMN as GMN-L. Moreover, since the parameterized FK inevitably loses the constraint-preserving property compared with the exact FK, therefore we also augment it with explicit constraint regularization, akin to what we did to EGNNReg. We hence denote this variant as GMN-LReg.
+
+We evaluate the performance of GMN-L, GMN-LReg and compare them with GMN with exact FK as well as EGNN and EGNNReg in Table 11. We interestingly find that GMN-L consistently outperforms EGNN in various settings (as well as the regularized version), which again verifies both the validity of our proposed equivariant message passing layer and the efficacy of leveraging objectlevel message (i.e., $\ddot { q } _ { k } ^ { l ^ { \top } }$ ) for the inference of FK. At the same time, GMN-L and GMN-LReg yield a minor gap with GMN, showing the evidence that hard-coding the constraints replaces a nontrivial amount of learning complexity.
+
+Table 11: Comparison with GMN-L and GMN-LReg.   
+
+<table><tr><td></td><td colspan="5">|Train|= 500</td><td colspan="5">|Train| = 1500</td></tr><tr><td></td><td>1,2.0</td><td>2.,0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3,3</td><td>1,2.0</td><td>2,0,1</td><td>3,2,1</td><td>0,10,0</td><td>5,3,3</td></tr><tr><td>EGNN</td><td>2.81</td><td>2.27</td><td>4.67</td><td>4.75</td><td>4.59</td><td>2.59</td><td>1.86</td><td>2.54</td><td>2.79</td><td>3.25</td></tr><tr><td>EGNNReg</td><td>2.94</td><td>2.66</td><td>7.01</td><td>5.03</td><td>6.31</td><td>2.74</td><td>1.58</td><td>2.62</td><td>3.03</td><td>3.07</td></tr><tr><td>GMN-L</td><td>2.32</td><td>2.09</td><td>3.19</td><td>3.88</td><td>4.34</td><td>1.93</td><td>1.56</td><td>2.28</td><td>2.72</td><td>3.03</td></tr><tr><td>GMN-LReg</td><td>2.52</td><td>2.23</td><td>3.34</td><td>3.67</td><td>4.31</td><td>1.91</td><td>1.88</td><td>2.49</td><td>2.61</td><td>3.00</td></tr><tr><td>GMN</td><td>1.84</td><td>2.02</td><td>2.48</td><td>2.92</td><td>4.08</td><td>1.68</td><td>1.47</td><td>2.10</td><td>2.32</td><td>2.86</td></tr></table>
+
+# J ROBUSTNESS TO ERRORS IN THE PHYSICAL PRIOR OF CONSTRAINTS
+
+It is interesting to test the robustness of our model w.r.t. the noisy constraints. This scenario would sometimes arise in real-world scenarios where we might not be certain about the exact connectivity of the rigid body, and thus would involve slight errors in domain expertise. Since our paper focuses on the distance constraint other than the angle constraint, the following investigations will only involve noise into the stick connectivity. We design three random perturbation operations on the input rigid body prior: 1. (Join) randomly selecting 2 isolated particles and joining them as if there is a stick connecting; 2. (Split) randomly selecting an existing stick and splitting it as two isolated particles; 3. $( \mathrm { J o i n } + \mathrm { S p l i t } )$ conducting operation 1 and 2 at the same time; and 4. (Change in Length) randomly adding Gaussian noise $\mathcal { N } \bar { ( 0 , 0 . 1 L ) }$ to the length of a stick, where $L$ is its original length. Note that the operation is conducted independently for every training sample each time it is fed into the network.
+
+We summarize the results in Table 12. We observe that these perturbations, although somehow hinder the performance, in general do not jeopardize the performance too much (difference in MSE $\leq 0 . 3 0 )$ , indicating that GMN is not sensitive to slight errors of the input physical prior of the constraints and it is still able to learn to some degree of given the wrong constraints.
+
+Table 12: Robustness test in various scenarios.   
+
+<table><tr><td></td><td colspan="3">|Train| = 500</td><td colspan="3">|Train| = 1500</td></tr><tr><td></td><td>3,2,1</td><td>5,3,3</td><td>8,6,0</td><td>3,2,1</td><td>5,3,3</td><td>8,6,0</td></tr><tr><td>GMN</td><td>2.48</td><td>4.08</td><td>2.84</td><td>2.10</td><td>2.86</td><td>2.22</td></tr><tr><td>GMN w/ Join</td><td>2.59</td><td>4.27</td><td>2.98</td><td>2.22</td><td>3.16</td><td>2.37</td></tr><tr><td>GMN w/ Split</td><td>2.57</td><td>4.11</td><td>2.95</td><td>2.16</td><td>3.13</td><td>2.26</td></tr><tr><td>GMN w/ Join + Split</td><td>2.63</td><td>4.16</td><td>3.01</td><td>2.31</td><td>3.01</td><td>2.34</td></tr><tr><td>GMN w/ Change in Length</td><td>2.75</td><td>4.36</td><td>3.11</td><td>2.15</td><td>3.15</td><td>2.41</td></tr></table>
+
+# K MORE DISCUSSIONS ON THE DECOMPOSITION
+
+It is possible to decompose into bigger objects rather than just sticks. As a comparison, we further adopt the hinge-wise decomposition (i.e., decompose the system into particles and hinges), and investigate the performance on both MD17 and Motion Capture. We denote this model as GMN-LH, where H stands for hinges. The results are depicted in Table 13 and Table 14. On MD17, GMNLH yields a little bit worse performance than GMN-L on several molecules, while giving desirable results on Ethanol and Benzene. On Motion Capture, GMN-LH outperforms GMN-L by a small gap, while is still worse than GMN. By default, we still encourage to perform the decomposition via sticks as sticks are actually the basic building blocks of hinges and other larger rigid objects.
+
+Table 13: Prediction error $( \times 1 0 ^ { - 2 } )$ ) on MD17 dataset. Results averaged across 3 runs.   
+
+<table><tr><td>Aspirin Ethanol Malonaldehyde Naphthalene Salicylic</td><td>Benzene</td><td></td><td></td><td></td><td>Toluene</td></tr><tr><td>EGNN</td><td>14.41±0.15 62.40±0.53</td><td>4.64±0.01</td><td>13.64±0.01</td><td>0.47±0.02</td><td>1.02±0.02 11.78±0.07</td></tr><tr><td>GMN</td><td>10.14±0.03 48.12±0.404</td><td>4.83±0.01</td><td>13.11±0.03</td><td>0.40±0.01</td><td>0.91±0.01 10.22±0.08</td></tr><tr><td>GMN-L</td><td>9.76±0.11</td><td>54.17±0.69 4.63±0.01</td><td>12.82±0.03</td><td>0.41±0.01</td><td>0.59±0.01 0.88±0.01 10.45±0.04 0.59±0.01</td></tr><tr><td>GMN-LH</td><td>10.25±0.06 52.02±0.974</td><td>4.62±0.01</td><td>12.83±0.03</td><td>0.41±0.01</td><td>1.03±0.01 10.81±0.14 0.59±0.01</td></tr></table>
+
+Table 14: Prediction error $( \times 1 0 ^ { - 2 } )$ on motion capture. Results averaged across 3 runs.   
+
+<table><tr><td>EGNN</td><td>GMN</td><td>GMN-L</td><td>GMN-LH</td></tr><tr><td>59.1±2.1</td><td>43.9±1.1</td><td>50.9±0.7</td><td>48.7±1.1</td></tr></table>

parse/dev/VnAwNNJiwDb/VnAwNNJiwDb.md

@@ -0,0 +1,253 @@
+# Generating Long Videos of Dynamic Scenes
+
+Tim Brooks NVIDIA, UC Berkeley
+
+Janne Hellsten NVIDIA
+
+Miika Aittala NVIDIA
+
+Ting-Chun Wang NVIDIA
+
+Timo Aila NVIDIA
+
+Jaakko Lehtinen NVIDIA, Aalto University
+
+Ming-Yu Liu NVIDIA
+
+Alexei A. Efros UC Berkeley
+
+Tero Karras NVIDIA
+
+# Abstract
+
+We present a video generation model that accurately reproduces object motion, changes in camera viewpoint, and new content that arises over time. Existing video generation methods often fail to produce new content as a function of time while maintaining consistencies expected in real environments, such as plausible dynamics and object persistence. A common failure case is for content to never change due to over-reliance on inductive biases to provide temporal consistency, such as a single latent code that dictates content for the entire video. On the other extreme, without long-term consistency, generated videos may morph unrealistically between different scenes. To address these limitations, we prioritize the time axis by redesigning the temporal latent representation and learning long-term consistency from data by training on longer videos. We leverage a two-phase training strategy, where we separately train using longer videos at a low resolution and shorter videos at a high resolution. To evaluate the capabilities of our model, we introduce two new benchmark datasets with explicit focus on long-term temporal dynamics.
+
+# 1 Introduction
+
+Videos are data that change over time, with complex patterns of camera viewpoint, motion, deformation and occlusion. In certain respects, videos are unbounded — they may last arbitrarily long and there is no limit to the amount of new content that may become visible over time. Yet videos that depict the real world must also remain consistent with physical laws that dictate which changes over time are feasible. For example, the camera may only move through 3D space along a smooth path, objects cannot morph between each other, and time cannot go backward. Generating long videos thus requires the ability to produce endless new content while maintaining appropriate consistencies.
+
+In this work, we focus on generating long videos with rich dynamics and new content that arises over time. While existing video generation models can produce “infinite” videos, the type and amount of change along the time axis is highly limited. For example, a synthesized infinite video of a person talking will only include small motions of the mouth and head. Moreover, common video generation datasets often contain short clips with little new content over time, which may inadvertently bias the design choices toward training on short segments or pairs of frames, forcing content in videos to stay fixed, or using architectures with small temporal receptive fields.
+
+We make the time axis a first-class citizen for video generation. To this end, we introduce two new datasets that contain motion, changing camera viewpoints, and entrances/exits of objects and scenery over time. We learn long-term consistencies by training on long videos and design a temporal latent representation that enables modeling complex temporal changes. Figure 1 illustrates the rich motion and scenery changes that our model is capable of generating. See our webpage1 for video results, code, data and pretrained models.
+
+![](images/562863548ff907597e11c6cbb57974aa93aa276baa0e5f95dac2fcddfba84a77.jpg)  
+Figure 1: We aim to generate videos that accurately portray motion, changing camera viewpoint, and new content that arises over time. Top: Our horseback riding dataset exhibits these types of changes as the horse moves forward in the environment. Middle: StyleGAN-V, a state-of-the-art video generation baseline, is incapable of generating new content over time; the horse fails to move forward past the obstacle, the scene does not change, and the video morphs back and forth within a short window of motion. Bottom: Our novel video generation model prioritizes the time axis and generates realistic motion and scenery changes over long durations. The same videos can be viewed on the supplemental webpage.
+
+Our main contribution is a hierarchical generator architecture that employs a vast temporal receptive field and a novel temporal embedding. We employ a multi-resolution strategy, where we first generate videos at low resolution and then refine them using a separate super-resolution network. Naively training on long videos at high spatial resolution is prohibitively expensive, but we find that the main aspects of a video persist at a low spatial resolution. This observation allows us to train with long videos at low resolution and short videos at high resolution, enabling us to prioritize the time axis and ensure that long-term changes are accurately portrayed. The low-resolution and super-resolution networks are trained independently with an RGB bottleneck in between. This modular design allows iterating on each network independently and leveraging the same super-resolution network for different low-resolution network ablations.
+
+We compare our results to several recent video generative models and demonstrate state-of-the-art performance in producing long videos with realistic motion and changes in content. Code, new datasets, and pre-trained models on these datasets will be made available.
+
+# 2 Prior work
+
+Video generation is a challenging problem with a long history. The classic early works, Video Textures [50] and Dynamic Textures [10], model videos as textures by analogy with image textures. That is, they explicitly assume the content to be stationary over time, e.g., fire burning, smoke rising, foliage falling, pendulum swinging, etc., and use non-parametric [50] or parametric [10] approaches to model that stationary distribution. Although subsequent video synthesis works have dropped the “texture” moniker, much of the limitations remain similar — short training videos and models which produce little or no new objects entering the frame during the video. Below we summarize some of the more recent efforts on video generation.
+
+Unconditional video generation. Many video generation works are based on GANs [14], including early models that output fixed-length videos [1, 47, 60] and approaches that use recurrent networks to produce a sequence of latent codes used to generate frames [9, 12, 55, 56]. MoCoGAN [56] explicitly disentangles “motion” from “content” and keeps the latter fixed over the entire generated video. StyleGAN-V [52] is a recent state-of-the-art model we use as a primary baseline. Similar to MoCoGAN, StyleGAN-V employs a global latent code that controls content of an entire video. MoCoGAN-HD [55], which we also compare with, and StyleVideoGAN [12] attempt to generate videos by navigating the latent space of a pretrained StyleGAN2 model [29], but struggle to produce realistic motion. Unlike previous StyleGAN-based [28] video models, we prioritize the time axis in our generator through a new temporal latent representation, temporal upsampling, and spatiotemporal modulated convolutions. We also compare with DIGAN [66] that employs an implicit representation to generate the video pixel by pixel.
+
+Transformers are another class of models used for video generation [13, 42, 61, 65]. We compare with TATS [13] that generates long unconditional videos with transformers, improving upon VideoGPT [65]. Both TATS and VideoGPT employ a GPT-like autoregressive transformer [4] that represents videos as sequences of tokens. However, the resulting videos tend to accumulate error over time and often diverge or change too rapidly. The models are also expensive to train and deploy due to their autoregressive nature over time and space. In concurrent work, promising results in generating diverse videos have also been demonstrated using diffusion-based models [20].
+
+Conditional video prediction. A separate line of research focuses on predicting future video frames conditioned on one or more real video frames [3, 23, 34, 36, 39, 41] or past frames accompanied by an action label [6, 15, 30, 31]. Some video prediction methods focus specifically on generating infinite scenery by conditioning on camera trajectory [37, 44] and/or explicitly predicting depth [2, 37] to then simulate a virtual camera flying through a 3D scene. Our goal, on the other hand, is to support camera movement as well as moving objects by having the scene structure emerge implicitly.
+
+Multi-resolution training. Training at multiple scales is a common strategy for image generation models [7, 25, 43, 46, 58]. Transformer-based video generators also employ a related two-phase setup [65, 13]. Saito et al. [48] subsample frames at higher resolutions in their video generator architecture to improve efficiency. A similar idea is also used in SlowFast [11] networks where different network pathways are used for high and low frame rate video streams. Acharya et al. [1] propose a multi-scale GAN for video generation that increases both spatial resolution and sequence length during training to produce a fixed-length video. In contrast, our multi-resolution approach is designed to enable generating arbitrarily long videos with rich long-term dynamics by leveraging training of long sequences at low resolution.
+
+# 3 Our method
+
+Modeling the long-term temporal behavior observed in real videos presents us with two main challenges. First, we must use long enough sequences during training to capture the relevant effects; using, e.g., pairs of consecutive frames fails to provide meaningful training signal for effects that occur over several seconds. Second, we must ensure that the networks themselves are capable of operating over long time scales; if, e.g., the receptive field of the generator spans only 8 adjacent frames, any two frames taken more than 8 frames apart will necessarily be uncorrelated with each other.
+
+Figure 2a shows the overall design of our generator. We seed the generation process with a variablelength stream of temporal noise, consisting of 8 scalar components per frame drawn from i.i.d. Gaussian distribution. The temporal noise is first processed by a low-resolution generator to obtain a sequence of RGB frames at $6 4 ^ { 2 }$ resolution that are then refined by a separate super-resolution network to produce the final frames at $2 5 6 ^ { 2 }$ resolution.2 The role of the low-resolution generator is to model major aspects of the motion and scene composition, which necessitates strong expressive power and a large receptive field over time, whereas the super-resolution network is responsible for the more fine-grained task of hallucinating the remaining details.
+
+Our two-stage design provides maximum flexibility in terms of generating long videos. Specifically, the low-resolution generator is designed to be fully convolutional over time, so the duration and time offset of the generated video can be controlled by shifting and reshaping the temporal noise, respectively. The super-resolution network, on the other hand, operates on a frame-by-frame basis. It receives a short sequence of 9 consecutive low-resolution frames and outputs a single high-resolution frame; each output frame is processed independently using a sliding window. The combination of fully-convolutional and per-frame processing enables us to generate arbitrary frames in arbitrary order, which is highly desirable for, e.g., interactive editing and real-time playback.
+
+![](images/135a98a000cc85e629582a4e9adcff2c5aeed471b161a54e61b330b6a4210b4d.jpg)  
+Figure 2: Overview of our method. (a) To achieve long temporal receptive field and high spatial resolution, we split our generator into two components: a low-resolution generator, responsible for modeling major aspects of the motion and scene composition, and a super-resolution network, responsible for hallucinating fine details. (b) The low-resolution generator (Section 3.1) employs a wide temporal receptive field and is trained with sequences of 128 frames at $6 4 ^ { 2 }$ resolution. (c) The super-resolution network (Section 3.2) is conditioned on short sequences of low-resolution frames and trained to produce their plausible counterparts at $2 5 6 ^ { 2 }$ resolution.
+
+The low-resolution and super-resolution networks are modular with an RGB bottleneck in between. This greatly simplifies experimentation, since the networks are trained independently and can be used in different combinations during inference. We will first describe the training and architecture of the low-resolution generator in Section 3.1 and then discuss the super-resolution network in Section 3.2.
+
+# 3.1 Low-resolution generator
+
+Figure 2b shows our training setup for the low-resolution generator. In each iteration, we provide the generator with a fresh set of temporal noise to produce sequences of 128 frames (4.3 seconds at 30 fps). To train the discriminator, we sample corresponding sequences from the training data by choosing a random video and a random interval of 128 frames within that video.
+
+We have observed that training with long sequences tends to exacerbate the issue of overfitting [26]. As the sequence length increases, we suspect that it becomes harder for the generator to simultaneously model temporal dynamics at multiple time scales, but at the same time, easier for the discriminator to spot any mistakes. In practice, we have found strong discriminator augmentation [26, 69] to be necessary in order to stabilize the training. We employ DiffAug [69] using the same transformation for each frame in a sequence, as well as fractional time stretching between $\bar { \frac { 1 } { 2 } } \bar { \times }$ and $2 \times$ ; see Appendix C.1 for details.
+
+Architecture. Figure 3 illustrates the architecture of our low-resolution generator. Our main goal is to make the time axis a first-class citizen, including careful design of a temporal latent representation, temporal style modulation, spatiotemporal convolutions, and temporal upsamples. Through these mechanisms, our generator spans a vast temporal receptive field (5k frames), allowing it to represent temporal correlations at multiple time scales.
+
+We employ a style-based design, similar to Karras et al. [29, 27], that maps the input temporal noise into a sequence of intermediate latents $\{ w _ { t } \}$ used to modulate the behavior of each layer in the main synthesis path. Each intermediate latent is associated with a specific frame, but it can significantly influence the scene composition and temporal behavior of several frames through hierarchical 3D convolutions that appear in the main path.
+
+![](images/076266e0bcaa70f10582dc49f85bdf9ecb33cf99075855164135f9dc4acbcfee.jpg)  
+Figure 3: Low-resolution generator architecture, illustrated for $6 4 { \times } 3 6$ output. Left: The input temporal noise is mapped to a sequence of intermediate latents $\{ w _ { t } \}$ that modulate the intermediate activations of the main synthesis path. Top right: To facilitate the modeling of long-term dependencies, we enrich the temporal noise by passing it through a series of lowpass filters whose temporal footprints range all the way from 100 to 5000 frames. Bottom right: The main synthesis path consists of spatiotemporal (ST) and spatial (S) blocks that gradually increase the resolution over time and space.
+
+In order to reap the full benefits of the style-based design, it is crucial for the intermediate latents to capture long-term temporal correlations, such as weather changes or persistent objects. To this end, we adopt a scheme where we first enrich the input temporal noise using a series of temporal lowpass filters and then pass it through a fully-connected mapping network on a frame-by-frame basis. The goal of the lowpass filtering is to provide the mapping network with sufficient long-term context across a wide range of different time scales. Specifically, given a stream of temporal noise $z ( t ) \in \mathbb { R } ^ { 8 }$ , we compute the corresponding enriched representation $\mathbf { \boldsymbol { z } } ^ { \prime } ( t ) \in \mathbb { R } ^ { 1 2 8 \times 8 }$ as $z _ { i , j } ^ { \prime } = f _ { i } * z _ { j }$ where $\{ f _ { i } \}$ is a set of 128 lowpass filters whose temporal footprint ranges from 100 to 5000 frames, and $^ *$ denotes convolution over time; see Appendix C.2 for details.
+
+The main synthesis path starts by downsampling the temporal resolution of $\{ w _ { t } \}$ by $3 2 \times$ and concatenating it with a learned constant at $4 ^ { 2 ^ { \cdot } }$ resolution. It then gradually increases the temporal and spatial resolutions through a series of processing blocks, illustrated in Figure 3 (bottom right), focusing first on the time dimension (ST) and then the spatial dimensions (S). The first four blocks have 512 channels, followed by two blocks with 256, two with 128 and two with 64 channels. The processing blocks consist of the same basic building blocks as StyleGAN2 [29] and StyleGAN3 [27] with the addition of a skip connection; the intermediate activations are normalized before each convolution [27] and modulated [29] according to an appropriately downsampled copy of $\{ w _ { t } \}$ . In practice, we employ bilinear upsampling [28] and use padding [27] for the time axis to eliminate boundary effects. Through the combination of our temporal latent representation and spatiotemporal processing blocks, our architecture is able to model complex and long-term patterns across time.
+
+For the discriminator, we employ an architecture that prioritizes the time axis via wide temporal receptive field, 3D spatiotemporal and 1D temporal convolutions, and spatial and temporal downsamples; see Appendix C.3 for details.
+
+# 3.2 Super-resolution network
+
+Figure 2c shows our training setup for the super-resolution network. Our video super-resolution network is a straightforward extension of StyleGAN3 [27] for conditional frame generation. Unlike the low-resolution network that outputs a sequence of frames and includes explicit temporal operations, the super-resolution generator outputs a single frame and only utilizes temporal information at the input, where the real low-resolution frame and 4 neighboring real low-resolution frames before and after in time are concatenated along the channel dimension to provide context. We remove the spatial Fourier feature inputs and resize and concatenate the stack of low-resolution frames to each layer throughout the generator. The generator architecture is otherwise unchanged from StyleGAN3, including the use of an intermediate latent code that is sampled per video. Low-resolution frames undergo augmentation prior to conditioning as part of the data pipeline, which helps ensure generalization to generated low-resolution images.
+
+![](images/1d02a18e9b63497dd58a504d7cecb0b26bb478a6a420a21bf8d827f5efc2b8d5.jpg)  
+Figure 4: Example real frames from training datasets. We introduce first-person datasets of (a) mountain biking and (b) horseback riding videos that contain complex motion and new content over time. We also evaluate on existing datasets of (c) nature drone footage and (d) sky timelapse videos.
+
+The super-res discriminator is a similar straightforward extension of the StyleGAN discriminator, with 4 low and high-resolution frames concatenated at the input. The only other change is the removal of the minibatch standard deviation layer that we found unnecessary in practice. Both low- and highresolution segments of 4 frames undergo adaptive augmentation [26] where the same augmentation is applied to all frames at both resolutions. Low-resolution segments also undergo aggressive dropout $p = 0 . 9$ probability of zeroing out the entire segment), which prevents the discriminator from relying too heavily on the conditioning signal; see Appendix D.1 for details.
+
+We find it remarkable that such a simple video super-resolution model appears sufficient for producing reasonably good high-resolution videos. We focus primarily on the low-resolution generator in our experiments, utilizing a single super-resolution network trained per dataset. We feel that replacing this simple network with a more advanced model from the video super-resolution literature [16, 24, 49, 54] is a promising avenue for future work.
+
+# 4 Datasets
+
+Most of the existing video datasets introduce little or no new content over time. For example, talking head datasets [8, 45, 62, 63] show the same person for the duration of each video. UCF101 [53] portrays diverse human actions, but the videos are short and contain limited camera motion and little or no new objects that enter the videos over time.
+
+To best evaluate our model, we introduce two new video datasets of first-person mountain biking and horseback riding (Figure 4a,b) that exhibit complex changes over time. Our new datasets include subject motion of the horse or biker, a first-person camera viewpoint that moves through space, and new scenery and objects over time. The videos are available in high definition and were manually trimmed to remove problematic segments, scene cuts, text overlays, obstructed views, etc. The mountain biking dataset has 1202 videos with a median duration of 330 frames at 30 fps, and the horseback dataset has 66 videos with a median duration of 6504 frames also at 30fps. We have permission from the content owners to publicly release the datasets for research purposes. We believe our new datasets will serve as important benchmarks for future work.
+
+We also evaluate our model on the ACID dataset [38] (Figure 4c) that contains significant camera motion but lacks other types of motion, as well as the commonly used SkyTimelapse dataset [67] (Figure 4d) that exhibits new content over time as the clouds pass by, but the videos are relatively homogeneous and the camera remains fixed.
+
+![](images/51a7018ce7ee7153bed2227caa13b3dc9ccca39dc48ab201bd0e52c57e0b9491.jpg)  
+Figure 5: Color similarity (Eq. 1) of real and generated videos as a function of frame separation, reported as the mean (solid lines) and standard deviation (shaded regions) over 1000 random clips.
+
+# 5 Results
+
+We evaluate our model through qualitative examination of the generated videos (Section 5.1), analyzing color change over time (Section 5.2), computing the FVD metric (Section 5.3), and ablating the key design choices (Section 5.4). We compare with StyleGAN-V [52] on all datasets. Mountain biking, horseback riding and ACID [37] datasets contain videos with a $1 6 { \times } 9$ widescreen aspect ratio. We train at $2 5 6 { \times } 1 4 4$ resolution on these datasets to preserve the aspect ratio. Since StyleGAN-V is based on StyleGAN2 [29], we can easily extend it to support non-square aspect ratios by masking real and generated frames during training. We found it necessary to increase the ${ \mathrm { R 1 } } \gamma$ hyperparameter by $1 0 \times$ to produce good results with StyleGAN-V on our new datasets that exhibit complex changes over time. We compare with MoCoGAN-HD [56], TATS [13] and DIGAN [66] using pre-trained models for the SkyTimelapse dataset at $1 2 8 ^ { 2 }$ resolution. For these comparisons, we train a separate super-resolution network to output the frames at $1 2 8 ^ { 2 }$ resolution, but use the same low-resolution generator as in the $2 5 6 ^ { 2 }$ comparison.
+
+# 5.1 Qualitative results
+
+The major qualitative difference in results is that our model generates realistic new content over time, whereas StyleGAN-V continually repeats the same content. The effect is best observed by watching videos on the supplemental webpage and is additionally illustrated in Figure 1. Scenery changes over time in real videos and our results as the horse moves forward through space. However, the videos generated by StyleGAN-V tend to morph back to the same scene at regular intervals. Similar repeated content from StyleGAN-V is apparent on all datasets. For example, results on the webpage for the SkyTimelapse dataset show that clouds generated by StyleGAN-V repeatedly move back and forth. MoCoGAN-HD and TATS suffer from unrealistic rapid changes over time that diverge, and DIGAN results contain periodic patterns visible in both space and time. Our model is capable of generating a constant stream of new clouds.
+
+As a further validation of our observations, we conducted a preliminary user study on Amazon Mechanical Turk. We created 50 pairs of videos for each of the 4 datasets. Each pair contained a random video generated by StyleGAN-V and one generated by our method, and we asked the participants which of them exhibited more realistic motion in a forced-choice response. Each pair was shown to 10 participants, resulting in a total of $5 0 { \times } 4 { \times } 1 0$ responses. Our method was preferred over $80 \%$ of the time for every dataset. Please see Appendix A.1 for details.
+
+# 5.2 Analyzing color change over time
+
+To gain insight into how well different methods produce new content at appropriate rates, we analyze how the overall color scheme changes as a function of time. We measure color similarity as the intersection between RGB color histograms; this serves as a simple proxy for actual content changes and helps reveal the biases of different models. Let $H ( x , i )$ denote a 3D color histogram function that computes the value of histogram bin $i \in [ 1 , \dots , N ^ { 3 } ]$ for the given image $x$ , normalized so that $\begin{array} { r } { \sum _ { i } H ( x , i ) = 1 } \end{array}$ . Given video clip $\pmb { x } = \{ x _ { t } \}$ and frame separation $t$ , we define the color similarity as
+
+$$
+S ( \boldsymbol x , t ) = \sum _ { i } \operatorname* { m i n } \big ( H ( \boldsymbol x _ { 0 } , i ) , ~ H ( \boldsymbol x _ { t } , i ) \big ) ,
+$$
+
+<table><tr><td rowspan="2"></td><td colspan="2">Biking</td><td colspan="2">Horseback</td><td colspan="2">ACID</td><td colspan="2">Sky 2562</td></tr><tr><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td></tr><tr><td>StyleGAN-V</td><td>533.3</td><td>353.7</td><td>427.0</td><td>319.2</td><td>112.4</td><td>91.5</td><td>151.2</td><td>48.4</td></tr><tr><td>with 10× R1γ</td><td>224.6</td><td>99.2</td><td>196.2</td><td>159.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Ours</td><td>113.7</td><td>83.8</td><td>95.9</td><td>113.5</td><td>166.6</td><td>127.3</td><td>152.7</td><td>116.5</td></tr></table>
+
+<table><tr><td rowspan="2"></td><td colspan="2">Sky 1282</td></tr><tr><td>FVD128</td><td>FVD16</td></tr><tr><td>MoCoGAN-HD</td><td>635.6</td><td>224.9</td></tr><tr><td>TATS</td><td>435.0</td><td>97.0</td></tr><tr><td>DIGAN</td><td>228.6</td><td>153.4</td></tr><tr><td>Ours</td><td>142.6</td><td>107.5</td></tr></table>
+
+Table 1: We compute FVD on segments of 128 and 16 frames $\mathrm { ( F V D _ { 1 2 8 } }$ and $\mathrm { F V D _ { 1 6 } }$ respectively), where lower is better. Left: Our model outperforms StyleGAN-V on horseback riding and mountain biking datasets – both of which contain complex motion and new content over time. Our model underperforms StyleGAN-V on ACID and SkyTimelapse despite qualitative improvements and favorable user study ratings in Section 5.1. Right: Our model outperforms MoCoGAN-HD, TATS and DIGAN baselines on SkyTimelapse at $1 2 8 ^ { \bar { 2 } }$ resolution on $\mathrm { F V D _ { 1 2 8 } }$ .
+
+where $S ( { \pmb x } , t ) = 1$ indicates that the color histograms are identical between $x _ { 0 }$ and $x _ { t }$ . In practice, we set $N = 2 0$ and report the mean and standard deviation of $S ( \cdot , t )$ , measured on 1000 random video clips containing 128 frames each.
+
+Figure 5 shows $S ( \cdot , t )$ as a function of $t$ for real and generated videos on each dataset. The curves trend downward over time for real videos as content and scenery gradually change. StyleGAN-V and DIGAN are biased toward colors changing too slowly — both of these models include a global latent code that is fixed over the entire video. On the other extreme, MoCoGAN-HD and TATS are biased toward colors changing too quickly. These models use recurrent and autoregressive networks, respectively, both of which suffer from accumulating errors. Our model closely matches the shape of the target curve, indicating that colors in our generated videos change at appropriate rates.
+
+Color change is a crude approximation of the complex changes over time in videos. In Appendix A.3 we also consider LPIPS [68] perceptual distance instead of color similarly and observe the same trends in most cases.
+
+# 5.3 Fréchet video distance (FVD)
+
+The commonly used Fréchet video distance (FVD) [57] attempts to measure similarity between real and generated video distributions. We find that FVD is sensitive to the realism of individual frames and motion over short segments, but that it does not capture long-term realism. For example, FVD is essentially blind to unrealistic repetition of content over time, which is prominent in StyleGAN-V videos on all of our datasets. We found FVD to be most useful in ablations, i.e., when comparing slightly different variants of the same architecture.
+
+FVD [57] computes the Wasserstein-2 distance [59] between sets of real and generated features extracted from a pre-trained I3D action classification model [5]. Skorokhodov et al. [52] note that FVD is highly sensitive to small implementation differences, down to the level of image compression settings, and that the reported results are not necessarily comparable between papers (Appendix C in [52]). We report all FVD results using consistent evaluation protocol, ensuring apples-to-apples comparison. We separately measure FVD using 128- and 16-frame segments, denoted by $\mathrm { F V D _ { 1 2 8 } }$ and $\mathrm { F V D _ { 1 6 } }$ , and sample 2048 random segments from both the dataset and generator in each case.
+
+Table 1 (left) reports FVD on all datasets for StyleGAN-V and our model. We outperform StyleGANV on horseback riding and mountain biking datasets that contain more complex changes over time, but underperform on ACID and slightly underperform on SkyTimelapse in terms of $\mathrm { F V D _ { 1 2 8 } }$ . However, this underperformance strongly disagrees with the conclusions from the qualitative user study in Section 5.1. We believe this discrepancy comes from StyleGAN-V producing better individual frames, and possibly better small-scale motion, but falling seriously short in recreating believable long-term realism – and the FVD being sensitive primarily to the former aspects. Table 1 (right) reports FVD metrics on MoCoGAN-HD, TATS, DIGAN and our model for SkyTimelapse at $1 2 8 ^ { \bar { 2 } }$ ; we outperform all baselines in terms of $\mathrm { F V D _ { 1 2 8 } }$ on this comparison.
+
+<table><tr><td></td><td>FVD128</td><td>FVD16</td></tr><tr><td>Ours</td><td>113.7</td><td>83.8</td></tr><tr><td>0.1× lowpass width</td><td>153.1</td><td>113.2</td></tr><tr><td>10× lowpass width</td><td>217.9</td><td>126.5</td></tr></table>
+
+<table><tr><td></td><td>FVD128</td><td>FVD16</td></tr><tr><td>Ours (128 frames)</td><td>113.7</td><td>83.8</td></tr><tr><td>16 frames</td><td>163.6</td><td>108.5</td></tr><tr><td>2 frames</td><td>396.8</td><td>169.4</td></tr></table>
+
+(a) Ablation of training sequence length
+
+(b) Ablation of temporal lowpass filter footprint
+
+Table 2: (a) Our model learns to generate realistic long videos by training on long videos; decreasing the sequence length used during training is consistently harmful. (b) The footprint of the temporal lowpass filters plays an important role in producing inputs to the low-resolution mapping network at appropriate temporal frequencies; changing the footprint by an order of magnitude hurts performance.
+
+![](images/9ddbaeb69662f5bc64cd08a6076e163ee665cc0fefd48220ce72d5ca271f91e1.jpg)  
+Figure 6: Evaluation of the super-resolution network. $^ { ( \mathbf { a } , \mathbf { b } ) }$ Generated low-resolution frames and the corresponding high-resolution frames produced by the super-resolution network. (c) The superresolution network yields remarkably good FVD when provided with real low-resolution videos as input; the overall quality of our results is largely dictated by the low-resolution generator.
+
+# 5.4 Ablations
+
+Training on long videos improves generation of long videos. Observing long videos during training helps our model learn long-term consistency, which is illustrated in Table 2a that ablates the sequence length used during training of the low-resolution generator. We found that the benefits of training with long videos only became evident after designing a generator architecture with appropriate temporal receptive field to utilize the rich training signal. Note that even though we ablate aspects of the low-resolution generator, we still compute FVD using the final high-resolution videos produced by the super-resolution network.
+
+Footprint of the temporal lowpass filters. Our temporal latent representation serves a vital role in expanding the receptive field of our generator, modeling patterns over different time scales, and enabling the generation of new content over time. While we primarily leverage long training videos to learn long-term consistencies from data, the size of our temporal lowpass filters plays a role in encouraging the low-resolution mapping network to learn correlations at appropriate time scales. Table 2b demonstrates the negative impact of using inappropriately sized filters. We find that our model performs well with the same filter configuration for all datasets, although it is possible that the ideal settings may vary slightly between datasets.
+
+Effectiveness of the super-resolution network. Figure 6a,b shows examples of low-resolution frames generated by our model along with the corresponding high-resolution frames produced by our super-resolution network; we find that the super-resolution network generally performs well. To ensure that the quality of our results is not disproportionately limited by the super-resolution network, we further measure FVD when providing the super-resolution network with real low-resolution videos as input in Figure 6c. Indeed, FVD greatly improves in this case, which indicates that there are still significant gains to be realized by further improving the low-resolution generator.
+
+# 5.5 Failure cases
+
+Separate low- and super-resolution networks makes the problem computationally feasible, but it may somewhat compromise the quality of the final high-resolution frames. We observed that “swirly” artifacts are most prominent in the super-resolution output and not in the low-resolution output. Our model also struggles with long-term consistency of small details (e.g., distant jumps in generated horseback riding videos) that begin to appear before quickly fading out. We believe these issues are due to limitations of our super-resolution network, and that improving the super-resolution network would benefit the model in this regard. Another failure case we observed is difficulty preserving 3D consistency for scenes with very little motion, such as in the ACID dataset. In cases where there is little motion, one may consider using an explicit 3D representation.
+
+# 6 Conclusions
+
+Video generation has historically focused on relatively short clips with little new content over time. We consider longer videos with complex temporal changes, and uncover several open questions and video generation practices worth reassessing — the temporal latent representation and generator architecture, the training sequence length and recipes for using long videos, and the right evaluation metrics for long-term dynamics.
+
+We have shown that representations over many time scales serve as useful building blocks for modeling complex motions and the introduction of new content over time. We feel that the form of the latent space most suitable for video remains an open, almost philosophical question, leaving a large design space to explore. For example, what is the right latent representation to model persistent objects that exit from a video and re-enter later in the video while maintaining a consistent identity?
+
+The benefits we find from training on longer sequences open up further questions. Would video generation benefit from even longer training sequences? Currently we train using segments of adjacent frames, but it might be beneficial to use larger frame spacings to cover longer time spans.
+
+Quantitative evaluation of the results continues to be challenging. As we observed, FVD goes only a part of the way, being essentially blind to repetitive, even very implausible results. Our tests with how the colors and LPIPS distance change as a function of time partially bridge this gap, but we feel that this area deserves a thorough, targeted investigation of its own. We hope our work encourages further research into video generation that focuses on more complex and longer-term changes over time.
+
+Negative societal impacts Our work falls within data-driven generative modeling, which, as a field, has well known potential for misuse with increasing quality improvements. The training of video generators is even more intensive computationally than training still image generators, increasing energy usage. Our project consumed 300MWh on an in-house cluster of V100 and A100 GPUs.
+
+Acknowledgements We thank William Peebles, Samuli Laine, Axel Sauer and David Luebke for helpful discussion and feedback; Ivan Skorokhodov for providing additional results and insight into the StyleGAN-V baseline; Tero Kuosmanen for maintaining compute infrastructure; Elisa Wallace Eventing (https://www.youtube.com/c/WallaceEventing) and Brian Kennedy (https://www.youtube.com/c/bkxc) for videos used to make the horseback riding and mountain biking datasets. Tim Brooks is supported by the National Science Foundation Graduate Research Fellowship under Grant No. 2020306087.
+
+# References
+
+[1] Dinesh Acharya, Zhiwu Huang, Danda Pani Paudel, and Luc Van Gool. Towards high resolution video generation with progressive growing of sliced wasserstein gans. CoRR, abs/1810.02419, 2018.   
+[2] Adil Kaan Akan, Sadra Safadoust, Erkut Erdem, Aykut Erdem, and Fatma Güney. Stochastic video prediction with structure and motion. CoRR, abs/2203.10528, 2022.   
+[3] Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. In Proc. ICLR, 2018.   
+[4] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Proc. NeurIPS, 33:1877–1901, 2020.   
+[5] João Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proc. CVPR, pages 4724–4733, 2017.   
+[6] Silvia Chiappa, Sébastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment simulators. In Proc. ICLR, 2017.   
+[7] Rewon Child. Very deep vaes generalize autoregressive models and can outperform them on images. arXiv preprint arXiv:2011.10650, 2020.   
+[8] Joon Son Chung, Arsha Nagrani, and Andrew Zisserman. Voxceleb2: Deep speaker recognition. In Interspeech, 2018.   
+[9] Aidan Clark, Jeff Donahue, and Karen Simonyan. Adversarial video generation on complex datasets. CoRR, abs/1907.06571, 2019.   
+[10] Gianfranco Doretto, Alessandro Chiuso, Ying Nian Wu, and Stefano Soatto. Dynamic textures. International Journal of Computer Vision, 51(2):91–109, 2003.   
+[11] Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. In Proceedings of the IEEE/CVF international conference on computer vision, pages 6202–6211, 2019.   
+[12] Gereon Fox, Ayush Tewari, Mohamed Elgharib, and Christian Theobalt. Stylevideogan: A temporal generative model using a pretrained stylegan. CoRR, abs/2107.07224, 2021.   
+[13] Songwei Ge, Thomas Hayes, Harry Yang, Xi Yin, Guan Pang, David Jacobs, Jia-Bin Huang, and Devi Parikh. Long video generation with time-agnostic vqgan and time-sensitive transformer. CoRR, abs/2204.03638, 2022.   
+[14] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Proc. NIPS, 27, 2014.   
+[15] David Ha and Jürgen Schmidhuber. World models. CoRR, abs/1803.10122, 2018.   
+[16] Muhammad Haris, Gregory Shakhnarovich, and Norimichi Ukita. Recurrent back-projection network for video super-resolution. In Proc. CVPR, pages 3897–3906, 2019.   
+[17] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   
+[18] Geoffrey Hinton, Nitish Srivastava, and Kevin Swersky. Neural networks for machine learning lecture 6a overview of mini-batch gradient descent. Cited on, 14(8):2, 2012.   
+[19] Jonathan Ho, Chitwan Saharia, William Chan, David J Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. Journal of Machine Learning Research, 23(47):1–33, 2022.   
+[20] Jonathan Ho, Tim Salimans, Alexey Gritsenko, William Chan, Mohammad Norouzi, and David J Fleet. Video diffusion models. CoRR, abs/2204.03458, 2022.   
+[21] Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European conference on computer vision, pages 694–711. Springer, 2016.   
+[22] James F Kaiser. Nonrecursive digital filter design using the i_0-sinh window function. In Proc. 1974 IEEE International Symposium on Circuits & Systems, San Francisco DA, April, pages 20–23, 1974.   
+[23] Nal Kalchbrenner, Aäron Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. In Proc. ICML, pages 1771–1779, 2017.   
+[24] Armin Kappeler, Seunghwan Yoo, Qiqin Dai, and Aggelos K Katsaggelos. Video superresolution with convolutional neural networks. IEEE transactions on computational imaging, 2(2):109–122, 2016.   
+[25] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In Proc. ICLR, 2018.   
+[26] Tero Karras, Miika Aittala, Janne Hellsten, Samuli Laine, Jaakko Lehtinen, and Timo Aila. Training generative adversarial networks with limited data. In Proc. NeurIPS, 2020.   
+[27] Tero Karras, Miika Aittala, Samuli Laine, Erik Härkönen, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Alias-free generative adversarial networks. In Proc. NeurIPS, 2021.   
+[28] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proc. CVPR, pages 4401–4410, 2019.   
+[29] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proc. CVPR, pages 8110–8119, 2020.   
+[30] Seung Wook Kim, Jonah Philion, Antonio Torralba, and Sanja Fidler. Drivegan: Towards a controllable high-quality neural simulation. In Proc. CVPR, pages 5820–5829, 2021.   
+[31] Seung Wook Kim, Yuhao Zhou, Jonah Philion, Antonio Torralba, and Sanja Fidler. Learning to Simulate Dynamic Environments with GameGAN. In Proc. CVPR, Jun. 2020.   
+[32] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[33] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25, 2012.   
+[34] Manoj Kumar, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, and Durk Kingma. Videoflow: A conditional flow-based model for stochastic video generation. In Proc. ICLR, 2020.   
+[35] Tuomas Kynkäänniemi, Tero Karras, Miika Aittala, Timo Aila, and Jaakko Lehtinen. The role of imagenet classes in fréchet inception distance. arXiv preprint arXiv:2203.06026, 2022.   
+[36] Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. CoRR, abs/1804.01523, 2018.   
+[37] Andrew Liu, Richard Tucker, Varun Jampani, Ameesh Makadia, Noah Snavely, and Angjoo Kanazawa. Infinite nature: Perpetual view generation of natural scenes from a single image. In Proc. ICCV, 2021.   
+[38] Andrew Liu, Richard Tucker, Varun Jampani, Ameesh Makadia, Noah Snavely, and Angjoo Kanazawa. Infinite nature: Perpetual view generation of natural scenes from a single image. In Proc. CVPR, 2021.   
+[39] Pauline Luc, Aidan Clark, Sander Dieleman, Diego de Las Casas, Yotam Doron, Albin Cassirer, and Karen Simonyan. Transformation-based adversarial video prediction on large-scale data. CoRR, abs/2003.04035, 2020.   
+[40] Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Which training methods for gans do actually converge? In International Conference on Machine Learning (ICML), 2018.   
+[41] Charlie Nash, João Carreira, Jacob Walker, Iain Barr, Andrew Jaegle, Mateusz Malinowski, and Peter Battaglia. Transframer: Arbitrary frame prediction with generative models. CoRR, abs/2203.09494, 2022.   
+[42] Ruslan Rakhimov, Denis Volkhonskiy, Alexey Artemov, Denis Zorin, and Evgeny Burnaev. Latent video transformer. CoRR, abs/2006.10704, 2020.   
+[43] Ali Razavi, Aaron Van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with vq-vae-2. Proc. NeurIPS, 32, 2019.   
+[44] Xuanchi Ren and Xiaolong Wang. Look outside the room: Synthesizing a consistent long-term 3d scene video from a single image. In Proc. CVPR, 2022.   
+[45] Andreas Rössler, Davide Cozzolino, Luisa Verdoliva, Christian Riess, Justus Thies, and Matthias Nießner. Faceforensics: A large-scale video dataset for forgery detection in human faces. arXiv preprint arXiv:1803.09179, 2018.   
+[46] Chitwan Saharia, Jonathan Ho, William Chan, Tim Salimans, David J Fleet, and Mohammad Norouzi. Image super-resolution via iterative refinement. arXiv:2104.07636, 2021.   
+[47] Masaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In Proc. ICCV, pages 2830–2839, 2017.   
+[48] Masaki Saito, Shunta Saito, Masanori Koyama, and Sosuke Kobayashi. Train sparsely, generate densely: Memory-efficient unsupervised training of high-resolution temporal gan. International Journal of Computer Vision, 128(10):2586–2606, 2020.   
+[49] Mehdi S. M. Sajjadi, Raviteja Vemulapalli, and Matthew Brown. Frame-recurrent video super-resolution. In Proc. CVPR, 2018.   
+[50] Arno Schödl, Richard Szeliski, David H. Salesin, and Irfan Essa. Video textures. In Proc. SIGGRAPH, page 489–498, 2000.   
+[51] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+[52] Ivan Skorokhodov, Sergey Tulyakov, and Mohamed Elhoseiny. Stylegan-v: A continuous video generator with the price, image quality and perks of stylegan2. CoRR, abs/2112.14683, 2021.   
+[53] Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. In Proc. ICCV, 2013.   
+[54] Xin Tao, Hongyun Gao, Renjie Liao, Jue Wang, and Jiaya Jia. Detail-revealing deep video super-resolution. In Proc. ICCV, 2017.   
+[55] Yu Tian, Jian Ren, Menglei Chai, Kyle Olszewski, Xi Peng, Dimitris N. Metaxas, and Sergey Tulyakov. A good image generator is what you need for high-resolution video synthesis. In Proc. ICLR, 2021.   
+[56] Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. Mocogan: Decomposing motion and content for video generation. In Proc. CVPR, pages 1526–1535, 2018.   
+[57] Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges. CoRR, abs/1812.01717, 2018.   
+[58] Arash Vahdat and Jan Kautz. NVAE: A deep hierarchical variational autoencoder. In Proc. NeurIPS, 2020.   
+[59] Leonid Nisonovich Vaserstein. Markov processes over denumerable products of spaces, describing large systems of automata. Problemy Peredachi Informatsii, 5(3):64–72, 1969.   
+[60] Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In Proc. NIPS, 2016.   
+[61] Jacob Walker, Ali Razavi, and Aäron van den Oord. Predicting video with vqvae. CoRR, abs/2103.01950, 2021.   
+[62] Kaisiyuan Wang, Qianyi Wu, Linsen Song, Zhuoqian Yang, Wayne Wu, Chen Qian, Ran He, Yu Qiao, and Chen Change Loy. Mead: A large-scale audio-visual dataset for emotional talking-face generation. In Proc. ECCV, 2020.   
+[63] Ting-Chun Wang, Arun Mallya, and Ming-Yu Liu. One-shot free-view neural talking-head synthesis for video conferencing. In Proc. CVPR, 2021.   
+[64] Wei Xiong, Wenhan Luo, Lin Ma, Wei Liu, and Jiebo Luo. Learning to generate time-lapse videos using multi-stage dynamic generative adversarial networks. In Proc. CVPR, pages 2364–2373, 2018.   
+[65] Wilson Yan, Yunzhi Zhang, Pieter Abbeel, and Aravind Srinivas. Videogpt: Video generation using vq-vae and transformers. CoRR, abs/2104.10157, 2021.   
+[66] Sihyun Yu, Jihoon Tack, Sangwoo Mo, Hyunsu Kim, Junho Kim, Jung-Woo Ha, and Jinwoo Shin. Generating videos with dynamics-aware implicit generative adversarial networks. In Proc. ICLR, 2022.   
+[67] Jiangning Zhang, Chao Xu, Liang Liu, Mengmeng Wang, Xia Wu, Yong Liu, and Yunliang Jiang. Dtvnet: Dynamic time-lapse video generation via single still image. In Proc. ECCV, 2020.   
+[68] Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018.   
+[69] Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In Proc. NeurIPS, 2020.

parse/dev/VnAwNNJiwDb/VnAwNNJiwDb_content_list.json

@@ -0,0 +1,1092 @@
+[
+    {
+        "type": "text",
+        "text": "Generating Long Videos of Dynamic Scenes ",
+        "text_level": 1,
+        "bbox": [
+            232,
+            122,
+            764,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tim Brooks NVIDIA, UC Berkeley ",
+        "bbox": [
+            184,
+            200,
+            338,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Janne Hellsten NVIDIA ",
+        "bbox": [
+            356,
+            202,
+            464,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miika Aittala NVIDIA ",
+        "bbox": [
+            480,
+            200,
+            578,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ting-Chun Wang NVIDIA ",
+        "bbox": [
+            598,
+            200,
+            720,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Timo Aila NVIDIA ",
+        "bbox": [
+            740,
+            202,
+            812,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jaakko Lehtinen NVIDIA, Aalto University ",
+        "bbox": [
+            207,
+            251,
+            382,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu NVIDIA ",
+        "bbox": [
+            421,
+            250,
+            516,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexei A. Efros UC Berkeley ",
+        "bbox": [
+            555,
+            251,
+            665,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras NVIDIA ",
+        "bbox": [
+            702,
+            251,
+            790,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            314,
+            535,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a video generation model that accurately reproduces object motion, changes in camera viewpoint, and new content that arises over time. Existing video generation methods often fail to produce new content as a function of time while maintaining consistencies expected in real environments, such as plausible dynamics and object persistence. A common failure case is for content to never change due to over-reliance on inductive biases to provide temporal consistency, such as a single latent code that dictates content for the entire video. On the other extreme, without long-term consistency, generated videos may morph unrealistically between different scenes. To address these limitations, we prioritize the time axis by redesigning the temporal latent representation and learning long-term consistency from data by training on longer videos. We leverage a two-phase training strategy, where we separately train using longer videos at a low resolution and shorter videos at a high resolution. To evaluate the capabilities of our model, we introduce two new benchmark datasets with explicit focus on long-term temporal dynamics. ",
+        "bbox": [
+            233,
+            343,
+            766,
+            536
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            310,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Videos are data that change over time, with complex patterns of camera viewpoint, motion, deformation and occlusion. In certain respects, videos are unbounded — they may last arbitrarily long and there is no limit to the amount of new content that may become visible over time. Yet videos that depict the real world must also remain consistent with physical laws that dictate which changes over time are feasible. For example, the camera may only move through 3D space along a smooth path, objects cannot morph between each other, and time cannot go backward. Generating long videos thus requires the ability to produce endless new content while maintaining appropriate consistencies. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on generating long videos with rich dynamics and new content that arises over time. While existing video generation models can produce “infinite” videos, the type and amount of change along the time axis is highly limited. For example, a synthesized infinite video of a person talking will only include small motions of the mouth and head. Moreover, common video generation datasets often contain short clips with little new content over time, which may inadvertently bias the design choices toward training on short segments or pairs of frames, forcing content in videos to stay fixed, or using architectures with small temporal receptive fields. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We make the time axis a first-class citizen for video generation. To this end, we introduce two new datasets that contain motion, changing camera viewpoints, and entrances/exits of objects and scenery over time. We learn long-term consistencies by training on long videos and design a temporal latent representation that enables modeling complex temporal changes. Figure 1 illustrates the rich motion and scenery changes that our model is capable of generating. See our webpage1 for video results, code, data and pretrained models. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/562863548ff907597e11c6cbb57974aa93aa276baa0e5f95dac2fcddfba84a77.jpg",
+        "image_caption": [
+            "Figure 1: We aim to generate videos that accurately portray motion, changing camera viewpoint, and new content that arises over time. Top: Our horseback riding dataset exhibits these types of changes as the horse moves forward in the environment. Middle: StyleGAN-V, a state-of-the-art video generation baseline, is incapable of generating new content over time; the horse fails to move forward past the obstacle, the scene does not change, and the video morphs back and forth within a short window of motion. Bottom: Our novel video generation model prioritizes the time axis and generates realistic motion and scenery changes over long durations. The same videos can be viewed on the supplemental webpage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            88,
+            823,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contribution is a hierarchical generator architecture that employs a vast temporal receptive field and a novel temporal embedding. We employ a multi-resolution strategy, where we first generate videos at low resolution and then refine them using a separate super-resolution network. Naively training on long videos at high spatial resolution is prohibitively expensive, but we find that the main aspects of a video persist at a low spatial resolution. This observation allows us to train with long videos at low resolution and short videos at high resolution, enabling us to prioritize the time axis and ensure that long-term changes are accurately portrayed. The low-resolution and super-resolution networks are trained independently with an RGB bottleneck in between. This modular design allows iterating on each network independently and leveraging the same super-resolution network for different low-resolution network ablations. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We compare our results to several recent video generative models and demonstrate state-of-the-art performance in producing long videos with realistic motion and changes in content. Code, new datasets, and pre-trained models on these datasets will be made available. ",
+        "bbox": [
+            176,
+            582,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Prior work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            297,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Video generation is a challenging problem with a long history. The classic early works, Video Textures [50] and Dynamic Textures [10], model videos as textures by analogy with image textures. That is, they explicitly assume the content to be stationary over time, e.g., fire burning, smoke rising, foliage falling, pendulum swinging, etc., and use non-parametric [50] or parametric [10] approaches to model that stationary distribution. Although subsequent video synthesis works have dropped the “texture” moniker, much of the limitations remain similar — short training videos and models which produce little or no new objects entering the frame during the video. Below we summarize some of the more recent efforts on video generation. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            786
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unconditional video generation. Many video generation works are based on GANs [14], including early models that output fixed-length videos [1, 47, 60] and approaches that use recurrent networks to produce a sequence of latent codes used to generate frames [9, 12, 55, 56]. MoCoGAN [56] explicitly disentangles “motion” from “content” and keeps the latter fixed over the entire generated video. StyleGAN-V [52] is a recent state-of-the-art model we use as a primary baseline. Similar to MoCoGAN, StyleGAN-V employs a global latent code that controls content of an entire video. MoCoGAN-HD [55], which we also compare with, and StyleVideoGAN [12] attempt to generate videos by navigating the latent space of a pretrained StyleGAN2 model [29], but struggle to produce realistic motion. Unlike previous StyleGAN-based [28] video models, we prioritize the time axis in our generator through a new temporal latent representation, temporal upsampling, and spatiotemporal modulated convolutions. We also compare with DIGAN [66] that employs an implicit representation to generate the video pixel by pixel. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformers are another class of models used for video generation [13, 42, 61, 65]. We compare with TATS [13] that generates long unconditional videos with transformers, improving upon VideoGPT [65]. Both TATS and VideoGPT employ a GPT-like autoregressive transformer [4] that represents videos as sequences of tokens. However, the resulting videos tend to accumulate error over time and often diverge or change too rapidly. The models are also expensive to train and deploy due to their autoregressive nature over time and space. In concurrent work, promising results in generating diverse videos have also been demonstrated using diffusion-based models [20]. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Conditional video prediction. A separate line of research focuses on predicting future video frames conditioned on one or more real video frames [3, 23, 34, 36, 39, 41] or past frames accompanied by an action label [6, 15, 30, 31]. Some video prediction methods focus specifically on generating infinite scenery by conditioning on camera trajectory [37, 44] and/or explicitly predicting depth [2, 37] to then simulate a virtual camera flying through a 3D scene. Our goal, on the other hand, is to support camera movement as well as moving objects by having the scene structure emerge implicitly. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-resolution training. Training at multiple scales is a common strategy for image generation models [7, 25, 43, 46, 58]. Transformer-based video generators also employ a related two-phase setup [65, 13]. Saito et al. [48] subsample frames at higher resolutions in their video generator architecture to improve efficiency. A similar idea is also used in SlowFast [11] networks where different network pathways are used for high and low frame rate video streams. Acharya et al. [1] propose a multi-scale GAN for video generation that increases both spatial resolution and sequence length during training to produce a fixed-length video. In contrast, our multi-resolution approach is designed to enable generating arbitrarily long videos with rich long-term dynamics by leveraging training of long sequences at low resolution. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Our method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            308,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Modeling the long-term temporal behavior observed in real videos presents us with two main challenges. First, we must use long enough sequences during training to capture the relevant effects; using, e.g., pairs of consecutive frames fails to provide meaningful training signal for effects that occur over several seconds. Second, we must ensure that the networks themselves are capable of operating over long time scales; if, e.g., the receptive field of the generator spans only 8 adjacent frames, any two frames taken more than 8 frames apart will necessarily be uncorrelated with each other. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2a shows the overall design of our generator. We seed the generation process with a variablelength stream of temporal noise, consisting of 8 scalar components per frame drawn from i.i.d. Gaussian distribution. The temporal noise is first processed by a low-resolution generator to obtain a sequence of RGB frames at $6 4 ^ { 2 }$ resolution that are then refined by a separate super-resolution network to produce the final frames at $2 5 6 ^ { 2 }$ resolution.2 The role of the low-resolution generator is to model major aspects of the motion and scene composition, which necessitates strong expressive power and a large receptive field over time, whereas the super-resolution network is responsible for the more fine-grained task of hallucinating the remaining details. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our two-stage design provides maximum flexibility in terms of generating long videos. Specifically, the low-resolution generator is designed to be fully convolutional over time, so the duration and time offset of the generated video can be controlled by shifting and reshaping the temporal noise, respectively. The super-resolution network, on the other hand, operates on a frame-by-frame basis. It receives a short sequence of 9 consecutive low-resolution frames and outputs a single high-resolution frame; each output frame is processed independently using a sliding window. The combination of fully-convolutional and per-frame processing enables us to generate arbitrary frames in arbitrary order, which is highly desirable for, e.g., interactive editing and real-time playback. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            868
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/135a98a000cc85e629582a4e9adcff2c5aeed471b161a54e61b330b6a4210b4d.jpg",
+        "image_caption": [
+            "Figure 2: Overview of our method. (a) To achieve long temporal receptive field and high spatial resolution, we split our generator into two components: a low-resolution generator, responsible for modeling major aspects of the motion and scene composition, and a super-resolution network, responsible for hallucinating fine details. (b) The low-resolution generator (Section 3.1) employs a wide temporal receptive field and is trained with sequences of 128 frames at $6 4 ^ { 2 }$ resolution. (c) The super-resolution network (Section 3.2) is conditioned on short sequences of low-resolution frames and trained to produce their plausible counterparts at $2 5 6 ^ { 2 }$ resolution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            823,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The low-resolution and super-resolution networks are modular with an RGB bottleneck in between. This greatly simplifies experimentation, since the networks are trained independently and can be used in different combinations during inference. We will first describe the training and architecture of the low-resolution generator in Section 3.1 and then discuss the super-resolution network in Section 3.2. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Low-resolution generator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            390,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2b shows our training setup for the low-resolution generator. In each iteration, we provide the generator with a fresh set of temporal noise to produce sequences of 128 frames (4.3 seconds at 30 fps). To train the discriminator, we sample corresponding sequences from the training data by choosing a random video and a random interval of 128 frames within that video. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We have observed that training with long sequences tends to exacerbate the issue of overfitting [26]. As the sequence length increases, we suspect that it becomes harder for the generator to simultaneously model temporal dynamics at multiple time scales, but at the same time, easier for the discriminator to spot any mistakes. In practice, we have found strong discriminator augmentation [26, 69] to be necessary in order to stabilize the training. We employ DiffAug [69] using the same transformation for each frame in a sequence, as well as fractional time stretching between $\\bar { \\frac { 1 } { 2 } } \\bar { \\times }$ and $2 \\times$ ; see Appendix C.1 for details. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Architecture. Figure 3 illustrates the architecture of our low-resolution generator. Our main goal is to make the time axis a first-class citizen, including careful design of a temporal latent representation, temporal style modulation, spatiotemporal convolutions, and temporal upsamples. Through these mechanisms, our generator spans a vast temporal receptive field (5k frames), allowing it to represent temporal correlations at multiple time scales. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We employ a style-based design, similar to Karras et al. [29, 27], that maps the input temporal noise into a sequence of intermediate latents $\\{ w _ { t } \\}$ used to modulate the behavior of each layer in the main synthesis path. Each intermediate latent is associated with a specific frame, but it can significantly influence the scene composition and temporal behavior of several frames through hierarchical 3D convolutions that appear in the main path. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/076266e0bcaa70f10582dc49f85bdf9ecb33cf99075855164135f9dc4acbcfee.jpg",
+        "image_caption": [
+            "Figure 3: Low-resolution generator architecture, illustrated for $6 4 { \\times } 3 6$ output. Left: The input temporal noise is mapped to a sequence of intermediate latents $\\{ w _ { t } \\}$ that modulate the intermediate activations of the main synthesis path. Top right: To facilitate the modeling of long-term dependencies, we enrich the temporal noise by passing it through a series of lowpass filters whose temporal footprints range all the way from 100 to 5000 frames. Bottom right: The main synthesis path consists of spatiotemporal (ST) and spatial (S) blocks that gradually increase the resolution over time and space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            90,
+            821,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to reap the full benefits of the style-based design, it is crucial for the intermediate latents to capture long-term temporal correlations, such as weather changes or persistent objects. To this end, we adopt a scheme where we first enrich the input temporal noise using a series of temporal lowpass filters and then pass it through a fully-connected mapping network on a frame-by-frame basis. The goal of the lowpass filtering is to provide the mapping network with sufficient long-term context across a wide range of different time scales. Specifically, given a stream of temporal noise $z ( t ) \\in \\mathbb { R } ^ { 8 }$ , we compute the corresponding enriched representation $\\mathbf { \\boldsymbol { z } } ^ { \\prime } ( t ) \\in \\mathbb { R } ^ { 1 2 8 \\times 8 }$ as $z _ { i , j } ^ { \\prime } = f _ { i } * z _ { j }$ where $\\{ f _ { i } \\}$ is a set of 128 lowpass filters whose temporal footprint ranges from 100 to 5000 frames, and $^ *$ denotes convolution over time; see Appendix C.2 for details. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The main synthesis path starts by downsampling the temporal resolution of $\\{ w _ { t } \\}$ by $3 2 \\times$ and concatenating it with a learned constant at $4 ^ { 2 ^ { \\cdot } }$ resolution. It then gradually increases the temporal and spatial resolutions through a series of processing blocks, illustrated in Figure 3 (bottom right), focusing first on the time dimension (ST) and then the spatial dimensions (S). The first four blocks have 512 channels, followed by two blocks with 256, two with 128 and two with 64 channels. The processing blocks consist of the same basic building blocks as StyleGAN2 [29] and StyleGAN3 [27] with the addition of a skip connection; the intermediate activations are normalized before each convolution [27] and modulated [29] according to an appropriately downsampled copy of $\\{ w _ { t } \\}$ . In practice, we employ bilinear upsampling [28] and use padding [27] for the time axis to eliminate boundary effects. Through the combination of our temporal latent representation and spatiotemporal processing blocks, our architecture is able to model complex and long-term patterns across time. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the discriminator, we employ an architecture that prioritizes the time axis via wide temporal receptive field, 3D spatiotemporal and 1D temporal convolutions, and spatial and temporal downsamples; see Appendix C.3 for details. ",
+        "bbox": [
+            174,
+            799,
+            826,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Super-resolution network ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            390,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2c shows our training setup for the super-resolution network. Our video super-resolution network is a straightforward extension of StyleGAN3 [27] for conditional frame generation. Unlike the low-resolution network that outputs a sequence of frames and includes explicit temporal operations, the super-resolution generator outputs a single frame and only utilizes temporal information at the input, where the real low-resolution frame and 4 neighboring real low-resolution frames before and after in time are concatenated along the channel dimension to provide context. We remove the spatial Fourier feature inputs and resize and concatenate the stack of low-resolution frames to each layer throughout the generator. The generator architecture is otherwise unchanged from StyleGAN3, including the use of an intermediate latent code that is sampled per video. Low-resolution frames undergo augmentation prior to conditioning as part of the data pipeline, which helps ensure generalization to generated low-resolution images. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d02a18e9b63497dd58a504d7cecb0b26bb478a6a420a21bf8d827f5efc2b8d5.jpg",
+        "image_caption": [
+            "Figure 4: Example real frames from training datasets. We introduce first-person datasets of (a) mountain biking and (b) horseback riding videos that contain complex motion and new content over time. We also evaluate on existing datasets of (c) nature drone footage and (d) sky timelapse videos. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            823,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            277,
+            825,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The super-res discriminator is a similar straightforward extension of the StyleGAN discriminator, with 4 low and high-resolution frames concatenated at the input. The only other change is the removal of the minibatch standard deviation layer that we found unnecessary in practice. Both low- and highresolution segments of 4 frames undergo adaptive augmentation [26] where the same augmentation is applied to all frames at both resolutions. Low-resolution segments also undergo aggressive dropout $p = 0 . 9$ probability of zeroing out the entire segment), which prevents the discriminator from relying too heavily on the conditioning signal; see Appendix D.1 for details. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We find it remarkable that such a simple video super-resolution model appears sufficient for producing reasonably good high-resolution videos. We focus primarily on the low-resolution generator in our experiments, utilizing a single super-resolution network trained per dataset. We feel that replacing this simple network with a more advanced model from the video super-resolution literature [16, 24, 49, 54] is a promising avenue for future work. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            276,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Most of the existing video datasets introduce little or no new content over time. For example, talking head datasets [8, 45, 62, 63] show the same person for the duration of each video. UCF101 [53] portrays diverse human actions, but the videos are short and contain limited camera motion and little or no new objects that enter the videos over time. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To best evaluate our model, we introduce two new video datasets of first-person mountain biking and horseback riding (Figure 4a,b) that exhibit complex changes over time. Our new datasets include subject motion of the horse or biker, a first-person camera viewpoint that moves through space, and new scenery and objects over time. The videos are available in high definition and were manually trimmed to remove problematic segments, scene cuts, text overlays, obstructed views, etc. The mountain biking dataset has 1202 videos with a median duration of 330 frames at 30 fps, and the horseback dataset has 66 videos with a median duration of 6504 frames also at 30fps. We have permission from the content owners to publicly release the datasets for research purposes. We believe our new datasets will serve as important benchmarks for future work. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate our model on the ACID dataset [38] (Figure 4c) that contains significant camera motion but lacks other types of motion, as well as the commonly used SkyTimelapse dataset [67] (Figure 4d) that exhibits new content over time as the clouds pass by, but the videos are relatively homogeneous and the camera remains fixed. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/51a7018ce7ee7153bed2227caa13b3dc9ccca39dc48ab201bd0e52c57e0b9491.jpg",
+        "image_caption": [
+            "Figure 5: Color similarity (Eq. 1) of real and generated videos as a function of frame separation, reported as the mean (solid lines) and standard deviation (shaded regions) over 1000 random clips. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            95,
+            825,
+            226
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            286,
+            266,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our model through qualitative examination of the generated videos (Section 5.1), analyzing color change over time (Section 5.2), computing the FVD metric (Section 5.3), and ablating the key design choices (Section 5.4). We compare with StyleGAN-V [52] on all datasets. Mountain biking, horseback riding and ACID [37] datasets contain videos with a $1 6 { \\times } 9$ widescreen aspect ratio. We train at $2 5 6 { \\times } 1 4 4$ resolution on these datasets to preserve the aspect ratio. Since StyleGAN-V is based on StyleGAN2 [29], we can easily extend it to support non-square aspect ratios by masking real and generated frames during training. We found it necessary to increase the ${ \\mathrm { R 1 } } \\gamma$ hyperparameter by $1 0 \\times$ to produce good results with StyleGAN-V on our new datasets that exhibit complex changes over time. We compare with MoCoGAN-HD [56], TATS [13] and DIGAN [66] using pre-trained models for the SkyTimelapse dataset at $1 2 8 ^ { 2 }$ resolution. For these comparisons, we train a separate super-resolution network to output the frames at $1 2 8 ^ { 2 }$ resolution, but use the same low-resolution generator as in the $2 5 6 ^ { 2 }$ comparison. ",
+        "bbox": [
+            174,
+            318,
+            826,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Qualitative results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            339,
+            516
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The major qualitative difference in results is that our model generates realistic new content over time, whereas StyleGAN-V continually repeats the same content. The effect is best observed by watching videos on the supplemental webpage and is additionally illustrated in Figure 1. Scenery changes over time in real videos and our results as the horse moves forward through space. However, the videos generated by StyleGAN-V tend to morph back to the same scene at regular intervals. Similar repeated content from StyleGAN-V is apparent on all datasets. For example, results on the webpage for the SkyTimelapse dataset show that clouds generated by StyleGAN-V repeatedly move back and forth. MoCoGAN-HD and TATS suffer from unrealistic rapid changes over time that diverge, and DIGAN results contain periodic patterns visible in both space and time. Our model is capable of generating a constant stream of new clouds. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As a further validation of our observations, we conducted a preliminary user study on Amazon Mechanical Turk. We created 50 pairs of videos for each of the 4 datasets. Each pair contained a random video generated by StyleGAN-V and one generated by our method, and we asked the participants which of them exhibited more realistic motion in a forced-choice response. Each pair was shown to 10 participants, resulting in a total of $5 0 { \\times } 4 { \\times } 1 0$ responses. Our method was preferred over $80 \\%$ of the time for every dataset. Please see Appendix A.1 for details. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Analyzing color change over time ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            444,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To gain insight into how well different methods produce new content at appropriate rates, we analyze how the overall color scheme changes as a function of time. We measure color similarity as the intersection between RGB color histograms; this serves as a simple proxy for actual content changes and helps reveal the biases of different models. Let $H ( x , i )$ denote a 3D color histogram function that computes the value of histogram bin $i \\in [ 1 , \\dots , N ^ { 3 } ]$ for the given image $x$ , normalized so that $\\begin{array} { r } { \\sum _ { i } H ( x , i ) = 1 } \\end{array}$ . Given video clip $\\pmb { x } = \\{ x _ { t } \\}$ and frame separation $t$ , we define the color similarity as ",
+        "bbox": [
+            173,
+            797,
+            825,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8375231ab71dfa40c2c516ddd26824e76e39a7fd295400e180538836483f03d9.jpg",
+        "text": "$$\nS ( \\boldsymbol x , t ) = \\sum _ { i } \\operatorname* { m i n } \\big ( H ( \\boldsymbol x _ { 0 } , i ) , ~ H ( \\boldsymbol x _ { t } , i ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            891,
+            637,
+            916
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/aed0cd23184847a992332d19911b90ad29ecf5c2e2da92751224d498ef10a2d9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Biking</td><td colspan=\"2\">Horseback</td><td colspan=\"2\">ACID</td><td colspan=\"2\">Sky 2562</td></tr><tr><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td><td>FVD128</td><td>FVD16</td></tr><tr><td>StyleGAN-V</td><td>533.3</td><td>353.7</td><td>427.0</td><td>319.2</td><td>112.4</td><td>91.5</td><td>151.2</td><td>48.4</td></tr><tr><td>with 10× R1γ</td><td>224.6</td><td>99.2</td><td>196.2</td><td>159.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Ours</td><td>113.7</td><td>83.8</td><td>95.9</td><td>113.5</td><td>166.6</td><td>127.3</td><td>152.7</td><td>116.5</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            624,
+            162
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ea3c384c7087a778e04712608d86307fd09b7e31f357af62724239974900a7f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Sky 1282</td></tr><tr><td>FVD128</td><td>FVD16</td></tr><tr><td>MoCoGAN-HD</td><td>635.6</td><td>224.9</td></tr><tr><td>TATS</td><td>435.0</td><td>97.0</td></tr><tr><td>DIGAN</td><td>228.6</td><td>153.4</td></tr><tr><td>Ours</td><td>142.6</td><td>107.5</td></tr></table>",
+        "bbox": [
+            643,
+            88,
+            816,
+            164
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: We compute FVD on segments of 128 and 16 frames $\\mathrm { ( F V D _ { 1 2 8 } }$ and $\\mathrm { F V D _ { 1 6 } }$ respectively), where lower is better. Left: Our model outperforms StyleGAN-V on horseback riding and mountain biking datasets – both of which contain complex motion and new content over time. Our model underperforms StyleGAN-V on ACID and SkyTimelapse despite qualitative improvements and favorable user study ratings in Section 5.1. Right: Our model outperforms MoCoGAN-HD, TATS and DIGAN baselines on SkyTimelapse at $1 2 8 ^ { \\bar { 2 } }$ resolution on $\\mathrm { F V D _ { 1 2 8 } }$ . ",
+        "bbox": [
+            173,
+            172,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $S ( { \\pmb x } , t ) = 1$ indicates that the color histograms are identical between $x _ { 0 }$ and $x _ { t }$ . In practice, we set $N = 2 0$ and report the mean and standard deviation of $S ( \\cdot , t )$ , measured on 1000 random video clips containing 128 frames each. ",
+        "bbox": [
+            176,
+            318,
+            823,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows $S ( \\cdot , t )$ as a function of $t$ for real and generated videos on each dataset. The curves trend downward over time for real videos as content and scenery gradually change. StyleGAN-V and DIGAN are biased toward colors changing too slowly — both of these models include a global latent code that is fixed over the entire video. On the other extreme, MoCoGAN-HD and TATS are biased toward colors changing too quickly. These models use recurrent and autoregressive networks, respectively, both of which suffer from accumulating errors. Our model closely matches the shape of the target curve, indicating that colors in our generated videos change at appropriate rates. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Color change is a crude approximation of the complex changes over time in videos. In Appendix A.3 we also consider LPIPS [68] perceptual distance instead of color similarly and observe the same trends in most cases. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Fréchet video distance (FVD) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            416,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The commonly used Fréchet video distance (FVD) [57] attempts to measure similarity between real and generated video distributions. We find that FVD is sensitive to the realism of individual frames and motion over short segments, but that it does not capture long-term realism. For example, FVD is essentially blind to unrealistic repetition of content over time, which is prominent in StyleGAN-V videos on all of our datasets. We found FVD to be most useful in ablations, i.e., when comparing slightly different variants of the same architecture. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "FVD [57] computes the Wasserstein-2 distance [59] between sets of real and generated features extracted from a pre-trained I3D action classification model [5]. Skorokhodov et al. [52] note that FVD is highly sensitive to small implementation differences, down to the level of image compression settings, and that the reported results are not necessarily comparable between papers (Appendix C in [52]). We report all FVD results using consistent evaluation protocol, ensuring apples-to-apples comparison. We separately measure FVD using 128- and 16-frame segments, denoted by $\\mathrm { F V D _ { 1 2 8 } }$ and $\\mathrm { F V D _ { 1 6 } }$ , and sample 2048 random segments from both the dataset and generator in each case. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1 (left) reports FVD on all datasets for StyleGAN-V and our model. We outperform StyleGANV on horseback riding and mountain biking datasets that contain more complex changes over time, but underperform on ACID and slightly underperform on SkyTimelapse in terms of $\\mathrm { F V D _ { 1 2 8 } }$ . However, this underperformance strongly disagrees with the conclusions from the qualitative user study in Section 5.1. We believe this discrepancy comes from StyleGAN-V producing better individual frames, and possibly better small-scale motion, but falling seriously short in recreating believable long-term realism – and the FVD being sensitive primarily to the former aspects. Table 1 (right) reports FVD metrics on MoCoGAN-HD, TATS, DIGAN and our model for SkyTimelapse at $1 2 8 ^ { \\bar { 2 } }$ ; we outperform all baselines in terms of $\\mathrm { F V D _ { 1 2 8 } }$ on this comparison. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0ee9736d52e8eca1a18b7a3206d835363a0fb64c4babfa649d1c5f4f1166f9d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FVD128</td><td>FVD16</td></tr><tr><td>Ours</td><td>113.7</td><td>83.8</td></tr><tr><td>0.1× lowpass width</td><td>153.1</td><td>113.2</td></tr><tr><td>10× lowpass width</td><td>217.9</td><td>126.5</td></tr></table>",
+        "bbox": [
+            529,
+            89,
+            772,
+            148
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/beb63a19334a0a642f8bf1a2bb886e621d2ac43a8a4c17d551a6bed8d3008a93.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Ablation of training sequence length "
+        ],
+        "table_body": "<table><tr><td></td><td>FVD128</td><td>FVD16</td></tr><tr><td>Ours (128 frames)</td><td>113.7</td><td>83.8</td></tr><tr><td>16 frames</td><td>163.6</td><td>108.5</td></tr><tr><td>2 frames</td><td>396.8</td><td>169.4</td></tr></table>",
+        "bbox": [
+            212,
+            88,
+            455,
+            148
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(b) Ablation of temporal lowpass filter footprint ",
+        "bbox": [
+            511,
+            154,
+            790,
+            166
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2: (a) Our model learns to generate realistic long videos by training on long videos; decreasing the sequence length used during training is consistently harmful. (b) The footprint of the temporal lowpass filters plays an important role in producing inputs to the low-resolution mapping network at appropriate temporal frequencies; changing the footprint by an order of magnitude hurts performance. ",
+        "bbox": [
+            174,
+            175,
+            825,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ddbaeb69662f5bc64cd08a6076e163ee665cc0fefd48220ce72d5ca271f91e1.jpg",
+        "image_caption": [
+            "Figure 6: Evaluation of the super-resolution network. $^ { ( \\mathbf { a } , \\mathbf { b } ) }$ Generated low-resolution frames and the corresponding high-resolution frames produced by the super-resolution network. (c) The superresolution network yields remarkably good FVD when provided with real low-resolution videos as input; the overall quality of our results is largely dictated by the low-resolution generator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            244,
+            802,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            279,
+            448
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training on long videos improves generation of long videos. Observing long videos during training helps our model learn long-term consistency, which is illustrated in Table 2a that ablates the sequence length used during training of the low-resolution generator. We found that the benefits of training with long videos only became evident after designing a generator architecture with appropriate temporal receptive field to utilize the rich training signal. Note that even though we ablate aspects of the low-resolution generator, we still compute FVD using the final high-resolution videos produced by the super-resolution network. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            556
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Footprint of the temporal lowpass filters. Our temporal latent representation serves a vital role in expanding the receptive field of our generator, modeling patterns over different time scales, and enabling the generation of new content over time. While we primarily leverage long training videos to learn long-term consistencies from data, the size of our temporal lowpass filters plays a role in encouraging the low-resolution mapping network to learn correlations at appropriate time scales. Table 2b demonstrates the negative impact of using inappropriately sized filters. We find that our model performs well with the same filter configuration for all datasets, although it is possible that the ideal settings may vary slightly between datasets. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of the super-resolution network. Figure 6a,b shows examples of low-resolution frames generated by our model along with the corresponding high-resolution frames produced by our super-resolution network; we find that the super-resolution network generally performs well. To ensure that the quality of our results is not disproportionately limited by the super-resolution network, we further measure FVD when providing the super-resolution network with real low-resolution videos as input in Figure 6c. Indeed, FVD greatly improves in this case, which indicates that there are still significant gains to be realized by further improving the low-resolution generator. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 Failure cases ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            302,
+            816
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Separate low- and super-resolution networks makes the problem computationally feasible, but it may somewhat compromise the quality of the final high-resolution frames. We observed that “swirly” artifacts are most prominent in the super-resolution output and not in the low-resolution output. Our model also struggles with long-term consistency of small details (e.g., distant jumps in generated horseback riding videos) that begin to appear before quickly fading out. We believe these issues are due to limitations of our super-resolution network, and that improving the super-resolution network would benefit the model in this regard. Another failure case we observed is difficulty preserving 3D consistency for scenes with very little motion, such as in the ACID dataset. In cases where there is little motion, one may consider using an explicit 3D representation. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            305,
+            166
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Video generation has historically focused on relatively short clips with little new content over time. We consider longer videos with complex temporal changes, and uncover several open questions and video generation practices worth reassessing — the temporal latent representation and generator architecture, the training sequence length and recipes for using long videos, and the right evaluation metrics for long-term dynamics. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have shown that representations over many time scales serve as useful building blocks for modeling complex motions and the introduction of new content over time. We feel that the form of the latent space most suitable for video remains an open, almost philosophical question, leaving a large design space to explore. For example, what is the right latent representation to model persistent objects that exit from a video and re-enter later in the video while maintaining a consistent identity? ",
+        "bbox": [
+            174,
+            256,
+            825,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The benefits we find from training on longer sequences open up further questions. Would video generation benefit from even longer training sequences? Currently we train using segments of adjacent frames, but it might be beneficial to use larger frame spacings to cover longer time spans. ",
+        "bbox": [
+            174,
+            330,
+            825,
+            373
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation of the results continues to be challenging. As we observed, FVD goes only a part of the way, being essentially blind to repetitive, even very implausible results. Our tests with how the colors and LPIPS distance change as a function of time partially bridge this gap, but we feel that this area deserves a thorough, targeted investigation of its own. We hope our work encourages further research into video generation that focuses on more complex and longer-term changes over time. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Negative societal impacts Our work falls within data-driven generative modeling, which, as a field, has well known potential for misuse with increasing quality improvements. The training of video generators is even more intensive computationally than training still image generators, increasing energy usage. Our project consumed 300MWh on an in-house cluster of V100 and A100 GPUs. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements We thank William Peebles, Samuli Laine, Axel Sauer and David Luebke for helpful discussion and feedback; Ivan Skorokhodov for providing additional results and insight into the StyleGAN-V baseline; Tero Kuosmanen for maintaining compute infrastructure; Elisa Wallace Eventing (https://www.youtube.com/c/WallaceEventing) and Brian Kennedy (https://www.youtube.com/c/bkxc) for videos used to make the horseback riding and mountain biking datasets. Tim Brooks is supported by the National Science Foundation Graduate Research Fellowship under Grant No. 2020306087. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            266,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Dinesh Acharya, Zhiwu Huang, Danda Pani Paudel, and Luc Van Gool. Towards high resolution video generation with progressive growing of sliced wasserstein gans. CoRR, abs/1810.02419, 2018.   \n[2] Adil Kaan Akan, Sadra Safadoust, Erkut Erdem, Aykut Erdem, and Fatma Güney. Stochastic video prediction with structure and motion. CoRR, abs/2203.10528, 2022.   \n[3] Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. In Proc. ICLR, 2018.   \n[4] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Proc. NeurIPS, 33:1877–1901, 2020.   \n[5] João Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proc. CVPR, pages 4724–4733, 2017.   \n[6] Silvia Chiappa, Sébastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment simulators. In Proc. ICLR, 2017.   \n[7] Rewon Child. Very deep vaes generalize autoregressive models and can outperform them on images. arXiv preprint arXiv:2011.10650, 2020.   \n[8] Joon Son Chung, Arsha Nagrani, and Andrew Zisserman. Voxceleb2: Deep speaker recognition. In Interspeech, 2018.   \n[9] Aidan Clark, Jeff Donahue, and Karen Simonyan. Adversarial video generation on complex datasets. CoRR, abs/1907.06571, 2019.   \n[10] Gianfranco Doretto, Alessandro Chiuso, Ying Nian Wu, and Stefano Soatto. Dynamic textures. International Journal of Computer Vision, 51(2):91–109, 2003.   \n[11] Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. In Proceedings of the IEEE/CVF international conference on computer vision, pages 6202–6211, 2019.   \n[12] Gereon Fox, Ayush Tewari, Mohamed Elgharib, and Christian Theobalt. Stylevideogan: A temporal generative model using a pretrained stylegan. CoRR, abs/2107.07224, 2021.   \n[13] Songwei Ge, Thomas Hayes, Harry Yang, Xi Yin, Guan Pang, David Jacobs, Jia-Bin Huang, and Devi Parikh. Long video generation with time-agnostic vqgan and time-sensitive transformer. CoRR, abs/2204.03638, 2022.   \n[14] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Proc. NIPS, 27, 2014.   \n[15] David Ha and Jürgen Schmidhuber. World models. CoRR, abs/1803.10122, 2018.   \n[16] Muhammad Haris, Gregory Shakhnarovich, and Norimichi Ukita. Recurrent back-projection network for video super-resolution. In Proc. CVPR, pages 3897–3906, 2019.   \n[17] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   \n[18] Geoffrey Hinton, Nitish Srivastava, and Kevin Swersky. Neural networks for machine learning lecture 6a overview of mini-batch gradient descent. Cited on, 14(8):2, 2012.   \n[19] Jonathan Ho, Chitwan Saharia, William Chan, David J Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. Journal of Machine Learning Research, 23(47):1–33, 2022.   \n[20] Jonathan Ho, Tim Salimans, Alexey Gritsenko, William Chan, Mohammad Norouzi, and David J Fleet. Video diffusion models. CoRR, abs/2204.03458, 2022.   \n[21] Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European conference on computer vision, pages 694–711. Springer, 2016.   \n[22] James F Kaiser. Nonrecursive digital filter design using the i_0-sinh window function. In Proc. 1974 IEEE International Symposium on Circuits & Systems, San Francisco DA, April, pages 20–23, 1974.   \n[23] Nal Kalchbrenner, Aäron Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. In Proc. ICML, pages 1771–1779, 2017.   \n[24] Armin Kappeler, Seunghwan Yoo, Qiqin Dai, and Aggelos K Katsaggelos. Video superresolution with convolutional neural networks. IEEE transactions on computational imaging, 2(2):109–122, 2016.   \n[25] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In Proc. ICLR, 2018.   \n[26] Tero Karras, Miika Aittala, Janne Hellsten, Samuli Laine, Jaakko Lehtinen, and Timo Aila. Training generative adversarial networks with limited data. In Proc. NeurIPS, 2020.   \n[27] Tero Karras, Miika Aittala, Samuli Laine, Erik Härkönen, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Alias-free generative adversarial networks. In Proc. NeurIPS, 2021.   \n[28] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proc. CVPR, pages 4401–4410, 2019.   \n[29] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proc. CVPR, pages 8110–8119, 2020.   \n[30] Seung Wook Kim, Jonah Philion, Antonio Torralba, and Sanja Fidler. Drivegan: Towards a controllable high-quality neural simulation. In Proc. CVPR, pages 5820–5829, 2021.   \n[31] Seung Wook Kim, Yuhao Zhou, Jonah Philion, Antonio Torralba, and Sanja Fidler. Learning to Simulate Dynamic Environments with GameGAN. In Proc. CVPR, Jun. 2020.   \n[32] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[33] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25, 2012.   \n[34] Manoj Kumar, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, and Durk Kingma. Videoflow: A conditional flow-based model for stochastic video generation. In Proc. ICLR, 2020.   \n[35] Tuomas Kynkäänniemi, Tero Karras, Miika Aittala, Timo Aila, and Jaakko Lehtinen. The role of imagenet classes in fréchet inception distance. arXiv preprint arXiv:2203.06026, 2022.   \n[36] Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. CoRR, abs/1804.01523, 2018.   \n[37] Andrew Liu, Richard Tucker, Varun Jampani, Ameesh Makadia, Noah Snavely, and Angjoo Kanazawa. Infinite nature: Perpetual view generation of natural scenes from a single image. In Proc. ICCV, 2021.   \n[38] Andrew Liu, Richard Tucker, Varun Jampani, Ameesh Makadia, Noah Snavely, and Angjoo Kanazawa. Infinite nature: Perpetual view generation of natural scenes from a single image. In Proc. CVPR, 2021.   \n[39] Pauline Luc, Aidan Clark, Sander Dieleman, Diego de Las Casas, Yotam Doron, Albin Cassirer, and Karen Simonyan. Transformation-based adversarial video prediction on large-scale data. CoRR, abs/2003.04035, 2020.   \n[40] Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Which training methods for gans do actually converge? In International Conference on Machine Learning (ICML), 2018.   \n[41] Charlie Nash, João Carreira, Jacob Walker, Iain Barr, Andrew Jaegle, Mateusz Malinowski, and Peter Battaglia. Transframer: Arbitrary frame prediction with generative models. CoRR, abs/2203.09494, 2022.   \n[42] Ruslan Rakhimov, Denis Volkhonskiy, Alexey Artemov, Denis Zorin, and Evgeny Burnaev. Latent video transformer. CoRR, abs/2006.10704, 2020.   \n[43] Ali Razavi, Aaron Van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with vq-vae-2. Proc. NeurIPS, 32, 2019.   \n[44] Xuanchi Ren and Xiaolong Wang. Look outside the room: Synthesizing a consistent long-term 3d scene video from a single image. In Proc. CVPR, 2022.   \n[45] Andreas Rössler, Davide Cozzolino, Luisa Verdoliva, Christian Riess, Justus Thies, and Matthias Nießner. Faceforensics: A large-scale video dataset for forgery detection in human faces. arXiv preprint arXiv:1803.09179, 2018.   \n[46] Chitwan Saharia, Jonathan Ho, William Chan, Tim Salimans, David J Fleet, and Mohammad Norouzi. Image super-resolution via iterative refinement. arXiv:2104.07636, 2021.   \n[47] Masaki Saito, Eiichi Matsumoto, and Shunta Saito. Temporal generative adversarial nets with singular value clipping. In Proc. ICCV, pages 2830–2839, 2017.   \n[48] Masaki Saito, Shunta Saito, Masanori Koyama, and Sosuke Kobayashi. Train sparsely, generate densely: Memory-efficient unsupervised training of high-resolution temporal gan. International Journal of Computer Vision, 128(10):2586–2606, 2020.   \n[49] Mehdi S. M. Sajjadi, Raviteja Vemulapalli, and Matthew Brown. Frame-recurrent video super-resolution. In Proc. CVPR, 2018.   \n[50] Arno Schödl, Richard Szeliski, David H. Salesin, and Irfan Essa. Video textures. In Proc. SIGGRAPH, page 489–498, 2000.   \n[51] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \n[52] Ivan Skorokhodov, Sergey Tulyakov, and Mohamed Elhoseiny. Stylegan-v: A continuous video generator with the price, image quality and perks of stylegan2. CoRR, abs/2112.14683, 2021.   \n[53] Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. In Proc. ICCV, 2013.   \n[54] Xin Tao, Hongyun Gao, Renjie Liao, Jue Wang, and Jiaya Jia. Detail-revealing deep video super-resolution. In Proc. ICCV, 2017.   \n[55] Yu Tian, Jian Ren, Menglei Chai, Kyle Olszewski, Xi Peng, Dimitris N. Metaxas, and Sergey Tulyakov. A good image generator is what you need for high-resolution video synthesis. In Proc. ICLR, 2021.   \n[56] Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. Mocogan: Decomposing motion and content for video generation. In Proc. CVPR, pages 1526–1535, 2018.   \n[57] Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges. CoRR, abs/1812.01717, 2018.   \n[58] Arash Vahdat and Jan Kautz. NVAE: A deep hierarchical variational autoencoder. In Proc. NeurIPS, 2020.   \n[59] Leonid Nisonovich Vaserstein. Markov processes over denumerable products of spaces, describing large systems of automata. Problemy Peredachi Informatsii, 5(3):64–72, 1969.   \n[60] Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In Proc. NIPS, 2016.   \n[61] Jacob Walker, Ali Razavi, and Aäron van den Oord. Predicting video with vqvae. CoRR, abs/2103.01950, 2021.   \n[62] Kaisiyuan Wang, Qianyi Wu, Linsen Song, Zhuoqian Yang, Wayne Wu, Chen Qian, Ran He, Yu Qiao, and Chen Change Loy. Mead: A large-scale audio-visual dataset for emotional talking-face generation. In Proc. ECCV, 2020.   \n[63] Ting-Chun Wang, Arun Mallya, and Ming-Yu Liu. One-shot free-view neural talking-head synthesis for video conferencing. In Proc. CVPR, 2021.   \n[64] Wei Xiong, Wenhan Luo, Lin Ma, Wei Liu, and Jiebo Luo. Learning to generate time-lapse videos using multi-stage dynamic generative adversarial networks. In Proc. CVPR, pages 2364–2373, 2018.   \n[65] Wilson Yan, Yunzhi Zhang, Pieter Abbeel, and Aravind Srinivas. Videogpt: Video generation using vq-vae and transformers. CoRR, abs/2104.10157, 2021.   \n[66] Sihyun Yu, Jihoon Tack, Sangwoo Mo, Hyunsu Kim, Junho Kim, Jung-Woo Ha, and Jinwoo Shin. Generating videos with dynamics-aware implicit generative adversarial networks. In Proc. ICLR, 2022.   \n[67] Jiangning Zhang, Chao Xu, Liang Liu, Mengmeng Wang, Xia Wu, Yong Liu, and Yunliang Jiang. Dtvnet: Dynamic time-lapse video generation via single still image. In Proc. ECCV, 2020.   \n[68] Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018.   \n[69] Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han. Differentiable augmentation for data-efficient gan training. In Proc. NeurIPS, 2020. ",
+        "bbox": [
+            181,
+            684,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            35,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            795
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/slHNW9yRie0/slHNW9yRie0.md

@@ -0,0 +1,441 @@
+# COLD DIFFUSION: INVERTING ARBITRARY IMAGE TRANSFORMS WITHOUT NOISE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Standard diffusion models involve an image transform – adding Gaussian noise – and an image restoration operator that inverts this degradation. We observe that the generative behavior of diffusion models is not strongly dependent on the choice of image degradation, and in fact an entire family of generative models can be constructed by varying this choice. Even when using completely deterministic degradations (e.g., blur, masking, and more), the training and test-time update rules that underlie diffusion models can be easily generalized to create generative models. The success of these fully deterministic models calls into question the community’s understanding of diffusion models, which relies on noise in either gradient Langevin dynamics or variational inference, and paves the way for generalized diffusion models that invert arbitrary processes.
+
+![](images/1eb391fa3973b43618811285c2093ac9fbda9931dc7342cee650287550d689ba.jpg)  
+Figure 1: Demonstration of the forward and backward processes for both hot and cold diffusions. While standard diffusions are built on Gaussian noise (top row), we show that generative models can be built on arbitrary and even noiseless/cold image transforms, including the ImageNet-C snowification operator, and an animorphosis operator that adds a random animal image from AFHQ.
+
+# 1 INTRODUCTION
+
+Diffusion models have recently emerged as powerful tools for generative modeling (Ramesh et al., 2022). Diffusion models come in many flavors, but all are built around the concept of random noise removal; one trains an image restoration/denoising network that accepts an image contaminated with Gaussian noise, and outputs a denoised image. At test time, the denoising network is used to convert pure Gaussian noise into a photo-realistic image using an update rule that alternates between applying the denoiser and adding Gaussian noise. When the right sequence of updates is applied, complex generative behavior is observed.
+
+The origins of diffusion models, and also our theoretical understanding of these models, are strongly based on the role played by Gaussian noise during training and generation. Diffusion has been understood as a random walk around the image density function using Langevin dynamics (SohlDickstein et al., 2015; Song & Ermon, 2019), which requires Gaussian noise in each step. The walk begins in a high temperature (heavy noise) state, and slowly anneals into a “cold” state with little if any noise. Another line of work derives the loss for the denoising network using variational inference with a Gaussian prior (Ho et al., 2020; Song et al., 2021a; Nichol & Dhariwal, 2021).
+
+In this work, we examine the need for Gaussian noise, or any randomness at all, for diffusion models to work in practice. We consider generalized diffusion models that live outside the confines of the theoretical frameworks from which diffusion models arose. Rather than limit ourselves to models built around Gaussian noise, we consider models built around arbitrary image transformations like blurring, downsampling, etc. We train a restoration network to invert these deformations using a simple $\ell _ { p }$ loss. When we apply a sequence of updates at test time that alternate between the image restoration model and the image degradation operation, generative behavior emerges, and we obtain photo-realistic images.
+
+The existence of cold diffusions that require no Gaussian noise (or any randomness) during training or testing raises questions about the limits of our theoretical understanding of diffusion models. It also unlocks the door for potentially new types of generative models with very different properties than conventional diffusion seen so far.
+
+# 2 BACKGROUND
+
+Both the Langevin dynamics and variational inference interpretations of diffusion models rely on properties of the Gaussian noise used in the training and sampling pipelines. From the scorematching generative networks perspective (Song & Ermon, 2019; Song et al., 2021b), noise in the training process is critically thought to expand the support of the low-dimensional training distribution to a set of full measure in ambient space. The noise is also thought to act as data augmentation to improve score predictions in low density regions, allowing for mode mixing in the stochastic gradient Langevin dynamics (SGLD) sampling. The gradient signal in low-density regions can be further improved during sampling by injecting large magnitudes of noise in the early steps of SGLD and gradually reducing this noise in later stages.
+
+Kingma et al. (2021) propose a method to learn a noise schedule that leads to faster optimization. Using a classic statistical result, Kadkhodaie & Simoncelli (2021) show the connection between removing additive Gaussian noise and the gradient of the log of the noisy signal density in deterministic linear inverse problems. Here, we shed light on the role of noise in diffusion models through theoretical and empirical results in applications to inverse problems and image generation.
+
+Iterative neural models have been used for various inverse problems (Romano et al., 2016; Metzler et al., 2017). Recently, diffusion models have been applied to them (Song et al., 2021b) for the problems of deblurring, denoising, super-resolution, and compressive sensing (Whang et al., 2021; Kawar et al., 2021; Saharia et al., 2021; Kadkhodaie & Simoncelli, 2021).
+
+Although not their focus, previous works on diffusion models have included experiments with deterministic image generation (Song et al., 2021a; Dhariwal & Nichol, 2021; Karras et al., 2022) and in selected inverse problems (Kawar et al., 2022). Recently, Rissanen et al. (2022) use a combination of Gaussian noise and blurring as a forward process for diffusion. Though they show the feasibility of a different degradation, here we show definitively that noise is not a necessity in diffusion models, and we observe the effects of removing noise for a number of inverse problems.
+
+Despite prolific work on generative models in recent years, methods to probe the properties of learned distributions and measure how closely they approximate the real training data are by no means closed fields of investigation.
+
+Indirect feature space similarity metrics such as Inception Score (Salimans et al., 2016), Mode Score (Che et al., 2016), Frechet inception distance (FID) (Heusel et al., 2017), and Kernel inception distance (KID) (Binkowski et al., 2018) have been proposed and adopted to some extent, but they ´ have notable limitations (Barratt & Sharma, 2018). To adopt a popular frame of reference, we will use FID as the feature similarity metric for our experiments.
+
+# 3 GENERALIZED DIFFUSION
+
+Standard diffusion models are built around two components. First, there is an image degradation operator that contaminates images with Gaussian noise. Second, a trained restoration operator is created to perform denoising. The image generation process alternates between the application of these two operators. In this work, we consider the construction of generalized diffusions built around arbitrary degradation operations. These degradations can be randomized (as in the case of standard diffusion) or deterministic.
+
+# 3.1 MODEL COMPONENTS AND TRAINING
+
+Given an image $\boldsymbol { x } _ { 0 } \in \mathbb { R } ^ { N }$ , consider the degradation of $x _ { 0 }$ by operator $D$ with severity $t$ , denoted $x _ { t } = D ( x _ { 0 } , t )$ . The output distribution $D ( x _ { 0 } , t )$ of the degradation should vary continuously in $t$ , and the operator should satisfy $D ( x _ { 0 } , 0 ) = x _ { 0 }$ .
+
+In the standard diffusion framework, $D$ adds Gaussian noise with variance proportional to $t$ . In our generalized formulation, we choose $D$ to perform various other transformations such as blurring, masking out pixels, downsampling, and more, with severity that depends on $t$ . We explore a range of choices for $D$ in Section 4.
+
+We also require a restoration operator $R$ that (approximately) inverts $D$ . This operator has the property that $R ( x _ { t } , t ) \approx x _ { 0 }$ . In practice, this operator is implemented via a neural network parameterized by $\theta$ . The restoration network is trained via the minimization problem
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { x \sim \mathcal { X } } \| R _ { \theta } ( D ( x , t ) , t ) - x \| ,
+$$
+
+where $x$ denotes a random image sampled from distribution $\mathcal { X }$ and $\| \cdot \|$ denotes a norm, which we take to be $\ell _ { 1 }$ in our experiments. We have so far used the subscript $R _ { \theta }$ to emphasize the dependence of $R$ on $\theta$ during training, but we will omit this symbol for simplicity in the discussion below.
+
+# 3.2 SAMPLING FROM THE MODEL
+
+After choosing a degradation $D$ and training a model $R$ to perform the restoration, these operators can be used in tandem to invert severe degradations by using standard methods borrowed from the diffusion literature. For small degradations $\left( t \approx 0 \right)$ ), a single application of $R$ can be used to obtain a restored image in one shot. However, because $R$ is typically trained using a simple convex loss, it yields blurry results when used with large $t$ . Rather, diffusion models (Song et al., 2021a; Ho et al., 2020) perform generation by iteratively applying the denoising operator and then adding noise back to the image, with
+
+<table><tr><td>Algorithm 1 Naive Sampling Input: A degraded sample xt</td></tr><tr><td>for s=t,t-1,...,1 do xo←R(xs,s) xs-1= D(xo,s-1) end for</td></tr><tr><td>Return: xo Algorithm 2 Transformation Agnostic Cold Sampling</td></tr><tr><td>Input: A degraded sample xt fors=t,t-1,...,1do</td></tr></table>
+
+the level of added noise decreasing over time. This is the standard update sequence in Algorithm 1.
+
+When the restoration operator is perfect, i.e. when $R ( D ( x _ { 0 } , t ) , t ) = x _ { 0 }$ for all $t$ , one can easily see that Algorithm 1 produces exact iterates of the form $x _ { s } = D ( x _ { 0 } , s )$ . But what happens for imperfect restoration operators? In this case, errors can cause the iterates $x _ { s }$ to wander away from $D ( x _ { 0 } , s )$ , and inaccurate reconstruction may occur.
+
+We find that the standard sampling approach in Algorithm 1 (explained further in A.8) works well for noise-based diffusion, possibly because the restoration operator $R$ has been trained to correct (random Gaussian) errors in its inputs. However, we find that it yields poor results in the case of cold diffusions with smooth/differentiable degradations as demonstrated for a deblurring model in
+
+Figure 2. We propose Transformation Agnostic Cold Sampling (TACoS) in Algorithm 2, which we find to be superior for inverting smooth, cold degradations.
+
+This sampler has important mathematical properties that enable it to recover high quality results. Specifically, for a class of linear degradation operations, it can be shown to produce exact reconstruction (i.e. $x _ { s } = D ( x _ { 0 } , s ) )$ ) even when the restoration operator $R$ fails to perfectly invert $D$ . We discuss this in the following section.
+
+# 3.3 PROPERTIES OF TACOS
+
+It is clear from inspection that both Algorithms 1 and 2 perfectly reconstruct the iterate $x _ { s } ~ = ~ D ( x _ { 0 } , s )$ for all $s \ < \ t$ if the restoration operator is a perfect inverse for the degradation operator. In this section, we analyze the stability of these algorithms to errors in the restoration operator.
+
+For small values of $x$ and $s$ , TACoS as described in 2 is tolerant of error in the restoration operator $R$ .To see why, consider a model problem with a linear degradation function of the form $D ( x , s ) \approx x { \bar { + } } s \cdot e$ for
+
+![](images/33818f76daac3efec172adcb5ad1b32c3b4db43c35bc5f370d1286455ff0a099.jpg)  
+Figure 2: Comparison of sampling methods for unconditional generation using cold diffusion on the CelebA dataset. Iterations 2, 4, 8, 16, 32, 64, 128, 192, and 256 are presented. Top: Algorithm 1 produces compounding artifacts and fails to generate a new image. Bottom: TACoS succeeds in sampling a high quality image without noise.
+
+a constant vector $e$ . We chose this ansatz because the Taylor expansion of any smooth degradation $D ( x , s )$ around $x = x _ { 0 } , s = 0$ has the form $D ( x , s ) \approx x + s \cdot e ( x ) + { \mathrm { H O T } }$ where HOT denotes higher order terms. Note, however, the analysis below requires $e$ to be a constant that does not depend on $x$ . The constant/zeroth-order term in this Taylor expansion is zero because we assumed above that the degradation operator satisfies $D ( x , 0 ) = { \overset { \cdot } { x } }$ .
+
+For a degradation $D ( x , s )$ and any restoration operator $R$ , the term $x _ { s - 1 }$ in TACoS becomes
+
+$$
+\begin{array} { r l } & { x _ { s } - D ( R ( x _ { s } , s ) , s ) + D ( R ( x _ { s } , s ) , s - 1 ) = D ( x _ { 0 } , s ) - D ( R ( x _ { s } , s ) , s ) + D ( R ( x _ { s } , s ) , s - 1 ) } \\ & { \ = x _ { 0 } + s \cdot e - R ( x _ { s } , s ) - s \cdot e + R ( x _ { s } , s ) + ( s - 1 ) \cdot e = x _ { 0 } + ( s - 1 ) = D ( x _ { 0 } , s - 1 ) } \end{array}
+$$
+
+By induction, we see that the algorithm produces the value $x _ { s } = D ( x _ { 0 } , s )$ for all $s < t$ , regardless of the choice of $R$ . In other words, for any choice of $R$ , the iteration behaves the same as it would when $R$ is a perfect inverse for the degradation $D$ .
+
+By contrast, Algorithm 1 does not enjoy this behavior even for small values of $s$ . In fact, when $R$ is not a perfect inverse for $D$ , $x _ { 0 }$ is not a fixed point of the update rule in Algorithm 1 because $x _ { 0 } \neq D ( \bar { R ( x , 0 ) } , 0 ) = R ( x , 0 )$ and hence compounds errors. If $R$ does not perfectly invert $D$ we should expect Algorithm 1 to incur errors, even for small values of $s$ . Meanwhile, for small values of $s$ , the behavior of $D$ approaches its first-order Taylor expansion and Algorithm 2 becomes immune to errors in $R$ . Figure 2 demonstrates the stability of TACoS described in Algorithm 2 vs Algorithm 1 for a deblurring model. Note that our analysis is not meant to be a complete convergence theory, rather to highlight a desirable theoretical property of our method that a naive sampler lacks.
+
+# 4 GENERALIZED DIFFUSIONS WITH VARIOUS TRANSFORMATIONS
+
+In this section, we take the first step towards cold diffusion by reversing different degradations and hence performing conditional generation. We will extend our methods to perform unconditional (i.e. from scratch) generation in Section 5. We emprically evaluate generalized diffusion models trained on different degradations with TACoS proposed in Algorithm 2. We perform experiments on the vision tasks of deblurring, inpainting, super-resolution, and the unconventional task of synthetic snow removal. We perform our experiments on MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky, 2009), and CelebA (Liu et al., 2015). In each of these tasks, we gradually remove the information from the clean image, creating a sequence of images such that $D ( x _ { 0 } , t )$ retains less information than $D ( x _ { 0 } , t - 1 )$ . For these different tasks, we present both qualitative and quantitative results on a held-out testing dataset and demonstrate the importance of the sampling technique described in Algorithm 2. For all quantitative results in this section, the Frechet inception distance (FID) scores (Heusel et al., 2017) for degraded and reconstructed images are measured with respect to the testing data. Additional information about the quantitative results, convergence criteria, hyperparameters, and architecture of the models presented below can be found in the appendix.
+
+# 4.1 DEBLURRING
+
+We consider a generalized diffusion based on a Gaussian blur operation (as opposed to Gaussian noise) in which an image at step $t$ has more blur than at $t - 1$ . The forward process given the Gaussian kernels $\{ G _ { s } \}$ and the image $x _ { t - 1 }$ at step $t - 1$ can thus be written as
+
+$$
+x _ { t } = G _ { t } * x _ { t - 1 } = G _ { t } * \ldots * G _ { 1 } * x _ { 0 } = { \bar { G } } _ { t } * x _ { 0 } = D ( x _ { 0 } , t ) ,
+$$
+
+where $^ *$ denotes the convolution operator, which blurs an image using a kernel.
+
+We train a deblurring model by minimizing the loss equation 1, and then use TACoS to invert this blurred diffusion process for which we trained a DNN to predict the clean image $\scriptstyle { \hat { x } } _ { 0 }$ . Qualitative results are shown in Figure 3 and quantitative results in Table 1. Qualitatively, we can see that images created using the sampling process are sharper and in some cases completely different as compared to the direct reconstruction of the clean image. Quantitatively we can see that the reconstruction metrics such as RMSE and PSNR get worse when we use the sampling process, but on the other hand FID with respect to held-out test data improves. The qualitative improvements and decrease in FID show the benefits of the generalized sampling routine, which brings the learned distribution closer to the true data manifold.
+
+In the case of blur operator, the sampling routine can be thought of adding frequencies at each step. This is because the sampling routine involves the term $D ( \hat { x _ { 0 } } , t ) - D ( \hat { x _ { 0 } } , t - \mathbf { \bar { 1 } } )$ which in the case of blur becomes ${ \bar { G } } _ { t } * x _ { 0 } - { \bar { G } } _ { t - 1 } * x _ { 0 }$ . This results in a difference of Gaussians, which is a band pass filter and contains frequencies that were removed at step $t$ . Thus, in the sampling process, we sequentially add the frequencies that were removed during the degradation process.
+
+![](images/7374b17fa61b4fb9dfe001a2869705b4fa78d331cec6e81b367a6aa105bc579e.jpg)  
+Figure 3: Deblurring models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+Table 1: Quantitative metrics for quality of image reconstruction using deblurring models.   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="3">Degraded</td><td colspan="3">Sampled</td><td colspan="3">Direct</td></tr><tr><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td></tr><tr><td>MNIST</td><td>438.59</td><td>0.287</td><td>0.287</td><td>4.69</td><td>0.718</td><td>0.154</td><td>5.10</td><td>0.757</td><td>0.142</td></tr><tr><td>CIFAR-10</td><td>298.60</td><td>0.315</td><td>0.136</td><td>80.08</td><td>0.773</td><td>0.075</td><td>83.69</td><td>0.775</td><td>0.071</td></tr><tr><td>CelebA</td><td>382.81</td><td>0.254</td><td>0.193</td><td>26.14</td><td>0.568</td><td>0.093</td><td>36.37</td><td>0.607</td><td>0.083</td></tr></table>
+
+# 4.2 INPAINTING
+
+We define a schedule of transforms that progressively grays-out pixels from the input image. We remove pixels using a Gaussian mask as follows: For input images of size $n \times n$ we start with a 2D Gaussian curve of variance $\beta$ , discretized into an $n \times n$ array. We normalize so the peak of the curve has value 1, and subtract the result from 1 so the center of the mask as value 0. We randomize the location of the Gaussian mask for MNIST and CIFAR-10, but keep it centered for CelebA. We denote the final mask by $z _ { \beta }$ .
+
+Input images $x _ { 0 }$ are iteratively masked for $T$ steps via multiplication with a sequence of masks $\{ z _ { \beta _ { i } } \}$ with increasing $\beta _ { i }$ . We can control the amount of information removed at each step by tuning the $\beta _ { i }$ parameter. In the language of Section 3, $\begin{array} { r } { D ( x _ { 0 } , t ) = x _ { 0 } \cdot \prod _ { i = 1 } ^ { t } z _ { \beta _ { i } } } \end{array}$ , where the operator $\cdot$ denotes entry-wise multiplication.
+
+Figure 4 presents results on test images and compares the output of the inpainting model to the original image. The reconstructed images display reconstructed features qualitatively consistent with the context provided by the unperturbed regions of the image. We quantitatively assess the effectiveness of the inpainting models on each of the datasets by comparing distributional similarity metrics before and after the reconstruction. Our results are summarized in Table 2. Note, the FID scores here are computed with respect to the held-out validation set.
+
+![](images/a79ad5589e6263344c81f149014a3ba3ce0f8b618378dbab4e299af63b23929e.jpg)  
+Figure 4: Inpainting models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: Degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+Table 2: Quantitative metrics for quality of image reconstruction using inpainting models.   
+
+<table><tr><td>Dataset</td><td colspan="3">Degraded</td><td colspan="3">Sampled</td><td colspan="3">Direct</td></tr><tr><td></td><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td></tr><tr><td>MNIST</td><td>108.48</td><td>0.490</td><td>0.262</td><td>1.61</td><td>0.941</td><td>0.068</td><td>2.24</td><td>0.948</td><td>0.060</td></tr><tr><td>CIFAR-10</td><td>40.83</td><td>0.615</td><td>0.143</td><td>8.92</td><td>0.859</td><td>0.068</td><td>9.97</td><td>0.869</td><td>0.063</td></tr><tr><td>CelebA</td><td>127.85</td><td>0.663</td><td>0.155</td><td>5.73</td><td>0.917</td><td>0.043</td><td>7.74</td><td>0.922</td><td>0.039</td></tr></table>
+
+# 4.3 SUPER-RESOLUTION
+
+For this task, the degradation operator downsamples the image by a factor of two in each direction. The final resolution of $x _ { T }$ is $4 \times 4$ for MNIST and CIFAR-10 and $2 \times 2$ in the case of Celeb-A. After each down-sampling, the lower-resolution image is resized to the original image size, using nearestneighbor interpolation. More details are available in Appendix A.3
+
+Figure 5 presents example testing data inputs for all datasets and compares the output of the superresolution model to the original image. Though the reconstructed images are not perfect for the more challenging datasets, the reconstructed features are qualitatively consistent with the context provided by the low resolution image. Table 3 compares the distributional similarity metrics between degraded/reconstructed images and test samples.
+
+![](images/32d94cc6baaa2c1327a238725971a8191c688dbaa185c1aa434b546135cea566.jpg)  
+Figure 5: Superresolution models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+Table 3: Quantitative metrics for quality of image reconstruction using super-resolution models.   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="3">Degraded</td><td colspan="3">Sampled</td><td colspan="3">Direct</td></tr><tr><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td></tr><tr><td>MNIST</td><td>368.56</td><td>0.178</td><td>0.231</td><td>4.33</td><td>0.820</td><td>0.115</td><td>4.05</td><td>0.823</td><td>0.114</td></tr><tr><td>CIFAR-10</td><td>358.99</td><td>0.279</td><td>0.146</td><td>152.76</td><td>0.411</td><td>0.155</td><td>169.94</td><td>0.420</td><td>0.152</td></tr><tr><td>CelebA</td><td>349.85</td><td>0.335</td><td>0.225</td><td>96.92</td><td>0.381</td><td>0.201</td><td>112.84</td><td>0.400</td><td>0.196</td></tr></table>
+
+# 4.4 SNOWIFICATION
+
+Apart from traditional degradations, we additionally provide results for the task of synthetic snow removal using the offical implementation of the snowification transform from ImageNet-C (Hendrycks & Dietterich, 2019). The purpose of this experiment is to demonstrate that generalized diffusion can succeed even with exotic transforms that lack the scale-space and compositional properties of blur operators. Similar to other tasks, we degrade the images by adding snow, such that the level of snow increases with step $t$ . We provide more implementation details in Appendix.
+
+We illustrate our desnowification results in Figure 6. We present testing examples, as well as their snowified images, from all the datasets, and compare the desnowified results with the original images. The desnowified images feature near-perfect reconstruction results for CIFAR-10 examples with lighter snow, and exhibit visually distinctive restoration for Celeb-A examples with heavy snow. We provide quantitative results in Table 4.
+
+![](images/254a085d4eb1e1fc1982654d6e1706c8034a9f31796972f04a7975575551f238.jpg)  
+Figure 6: Desnowification models trained on the CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+Table 4: Quantitative metrics for quality of image reconstruction using desnowification models.   
+
+<table><tr><td>Dataset</td><td>FID</td><td>Degraded Image SSIM</td><td>RMSE</td><td>FID</td><td>Reconstruction SSIM</td><td>RMSE</td></tr><tr><td>CIFAR-10</td><td>125.63</td><td>0.419</td><td>0.327</td><td>31.10</td><td>0.074</td><td>0.838</td></tr><tr><td>CelebA</td><td>398.31</td><td>0.338</td><td>0.283</td><td>27.09</td><td>0.033</td><td>0.907</td></tr></table>
+
+# 5 COLD GENERATION
+
+Diffusion models can successfully learn the underlying distribution of training data, and thus generate diverse, high quality images (Song et al., 2021a; Dhariwal & Nichol, 2021; Jolicoeur-Martineau et al., 2021; Ho et al., 2022). We will first discuss deterministic generation using Gaussian noise and then discuss in detail unconditional generation using deblurring. Finally, we provide a proof of concept that the TACoS described in Algorithm 2 can be extended to other degradations.
+
+# 5.1 GENERATION USING DETERMINISTIC NOISE DEGRADATION
+
+Here we discuss image generation using a noise-based degradation presented in our notation from Section 3, which we will later prove is equivalent to DDIM (Song et al., 2021a). We use the following degradation operator: $D ( \dot { x _ { , } } t ) = \sqrt { \dot { \alpha _ { t } } } x + \sqrt { 1 - \alpha _ { t } } z$ .
+
+$D$ is an interpolation between the data point $x$ and a sampled noise pattern $z \in \mathcal { N } ( 0 , 1 )$ . During training, $D$ is applied once and thus $z$ is sampled once for every image in every batch. However, sampling involves iterative applications of the degradation operator $D$ , which poses the question of how to pick $z$ for the sequence of degradations $D$ applied in a single image generation.
+
+There are three possible choices for $z$ . The first would be to resample $z$ for each application of $D$ , but this would make the sampling process nondeterministic for a fixed starting point. Another option is to sample a noise pattern $z$ once for each separate image generation and reuse it in each application of $D$ . In Table 5 we refer to this approach as Fixed Noise. Finally, one can calculate the noise vector $z$ to be used in step $t$ of reconstruction by using the formula
+
+$$
+\widehat { z } ( x _ { t } , t ) = \frac { x _ { t } - \sqrt { \alpha _ { t } } R ( x _ { t } , t ) } { \sqrt { 1 - \alpha _ { t } } } .
+$$
+
+This method denoted Estimated Noise in Table 5 turns out to be equivalent to the deterministic sampling proposed in Song et al. (2021a). We discuss this equivalence in detail in Appendix A.6.
+
+# 5.2 IMAGE GENERATION USING BLUR
+
+The forward diffusion process in noise-based diffusion models has the advantage that the degraded image distribution at the final step $T$ is simply an isotropic Gaussian. One can therefore perform (unconditional) generation by first drawing a sample from the isotropic Gaussian, and sequentially denoising it with backward diffusion.
+
+When using blur as a degradation, the fully degraded images do not form a nice closed-form distribution that we can sample from. They do, however, form a simple enough distribution that can be modeled with simple methods. Note that every image $x _ { 0 }$ degenerates to an $x _ { T }$ that is constant (i.e., every pixel is the same color) for large $T$ . Furthermore, the constant value is exactly the channelwise mean of the RGB image $x _ { 0 }$ , and can be represented with a 3-vector. This 3-dimensional distribution is easily represented using a Gaussian mixture model (GMM). This GMM can be sampled to produce the random pixel values of a severely blurred image, which can be deblurred using cold diffusion to create a new image.
+
+Our generative model uses a blurring schedule where we progressively blur each image with a Gaussian kernel of size $2 7 \times 2 7$ over 300 steps. The standard deviation of the kernel starts at 1 and increases exponentially at the rate of 0.01. We then fit a simple GMM with one component to the distribution of channel-wise means. To generate an image from scratch, we sample the channel-wise mean from the GMM, expand the 3D vector into a $1 2 8 \times 1 2 8$ image with three channels, and then apply TACoS.
+
+Empirically, the presented pipeline generates images with high fidelity but low diversity, as reflected quantitatively by comparing the perfect symmetry column with results from hot diffusion in Table 5. We attribute this to the perfect correlation between pixels of $x _ { T }$ sampled from the channel-wise mean Gaussian mixture model. To break the symmetry between pixels, we add a small amount of Gaussian noise (of standard deviation 0.002) to each sampled $x _ { T }$ . As shown in Table 5, the simple trick drastically improves the quality of generated images. We also present the qualitative results for cold diffusion using blur transformation in Figure 7, and further discuss the necessity of TACoS proposed in Algorithm 2 for generation in Appendix A.7.
+
+Table 5: FID scores for CelebA and AFHQ datasets using hot (noise) and cold diffusion (blur transformation). Breaking the symmetry within pixels of the same channel further improves FID.   
+
+<table><tr><td></td><td colspan="2">Hot Diffusion</td><td colspan="2">Cold Diffusion</td></tr><tr><td>Dataset</td><td>Fixed Noise</td><td>Estimated Noise</td><td>Perfect symmetry</td><td>Broken symmetry</td></tr><tr><td>CelebA</td><td>59.91</td><td>23.11</td><td>97.00</td><td>49.45</td></tr><tr><td>AFHQ</td><td>25.62</td><td>20.59</td><td>93.05</td><td>54.68</td></tr></table>
+
+![](images/a2bd8c349ce00a5e7bddb2f498a55eccd56baa748bf89354e5cc857c7b3a7633.jpg)  
+Figure 7: Examples of generated samples from $1 2 8 \times 1 2 8$ CelebA and AFHQ datasets using cold diffusion with blur transformation
+
+# 5.3 GENERATION USING OTHER TRANSFORMATIONS
+
+In this section, we provide a proof of concept that generation can be extended to other transformations. Specifically, we show preliminary results on inpainting, super-resolution, and animorphosis.
+
+Inspired by the simplicity of the degraded image distribution for the blurring routine presented in the previous section, we use degradation routines with predictable final distributions here as well.
+
+To use the Gaussian mask transformation for generation, we modify the masking routine so the final degraded image is completely devoid of information. One might think a natural option is to send all of the images to a completely black image $x _ { T }$ , but this would not allow for any diversity in generation. To get around this maximally non-injective property, we instead make the mask turn all pixels to a random, solid color. This still removes all of the information from the image, but it allows us to recover different samples from the learned distribution via Algorithm 2 by starting off with different color images. More formally, a Gaussian mask $\begin{array} { r } { G _ { t } = \prod _ { i = 1 } ^ { t } \bar { z } _ { \beta _ { i } } } \end{array}$ is created in a similar way as discussed in the Section 4.2, but instead of multiplying it directly to the image $x _ { 0 }$ , we create $x _ { t }$ as $G _ { t } \cdot x _ { 0 } + ( 1 - G _ { t } ) \cdot c$ , where $c$ is an image of a randomly sampled color.
+
+For super-resolution, the routine down-samples to a resolution of $2 \times 2$ , or 4 values in each channel. These degraded images can be represented as one-dimensional vectors, and their distribution is modeled using one Gaussian distribution. Using the same methods described for generation using blurring described above, we sample from this Gaussian-fitted distribution of the lower-dimensional degraded image space and pass this sampled point through the generation process trained on superresolution data to create one output.
+
+Additionally to show one can invert nearly any transformation, we include a new transformation deemed animorphosis, where we iteratively transform a human face from CelebA to an animal face from AFHQ. Though we chose CelebA and AFHQ for our experimentation, in principle such interpolation can be done for any two initial data distributions.
+
+More formally, given an image √ $x$ and a random image $z$ sampled from the AFHQ manifold, $x _ { t }$ can be written as $\begin{array} { r } { \dot { x _ { t } } = \sqrt { \alpha _ { t } } x + \dot { \sqrt { 1 - \alpha _ { t } } } z } \end{array}$ . Note this is essentially the same as the noising procedure, but instead of adding noise we are adding a progressively higher weighted AFHQ image. In order to sample from the learned distribution, we sample a random image of an animal and use TACoS.
+
+We present results for the CelebA dataset, and hence the quantitative results in terms of FID scores for inpainting, super-resolution and animorphosis are 90.14, 92.91 and 48.51 respectively. We further show some qualitative samples in Figure 8, and in Figure 1.
+
+![](images/35eeb6fb2c914d6ec97b9f6439e9075e47667178071698fe8a40d6654e7fed85.jpg)  
+Figure 8: Preliminary demonstration of the generative abilities of other cold diffusins on the $1 2 8 \times$ 128 CelebA dataset. The top row is with animorphosis models, the middle row is with inpainting models, and the bottom row exhibits super-resolution models.
+
+# 6 CONCLUSION
+
+Existing diffusion models rely on Gaussian noise for both forward and reverse processes. In this work, we find that the random noise can be removed entirely from the diffusion model framework, and replaced with arbitrary transforms. In doing so, our generalization of diffusion models and their sampling procedures allows us to restore images afflicted by deterministic degradations such as blur, inpainting and downsampling. This framework paves the way for a more diverse landscape of diffusion models beyond the Gaussian noise paradigm. The different properties of these diffusions may prove useful for a range of applications, including image generation and beyond.
+
+# REPRODUCIBILITY STATEMENT
+
+We provided our full code base as supplementary material, which is a modified version of the traditional diffusion database found at https://github.com/lucidrains/denoising-diffusion-pytorch. To facilitate the reproducibility of our results, we have included detailed hyperparameters for training each of our cold diffusion models in Appendices A.1-A.5. Due to space constraints in the main body, we opted to present a relatively small number of qualitative results. Many more examples of both conditionally and unconditionally generated images can be found in the Appendix.
+
+# REFERENCES
+
+Shane Barratt and Rishi Sharma. A note on the inception score. arXiv preprint arXiv:1801.01973, 2018.
+
+Mikołaj Binkowski, Danica J Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd ´ gans. arXiv preprint arXiv:1801.01401, 2018.
+
+Tong Che, Yanran Li, Athul Paul Jacob, Yoshua Bengio, and Wenjie Li. Mode regularized generative adversarial networks. arXiv preprint arXiv:1612.02136, 2016.
+
+Prafulla Dhariwal and Alexander Quinn Nichol. Diffusion models beat gans on image synthesis. volume 34, 2021.
+
+Dan Hendrycks and Thomas G. Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, ICLR 2019. OpenReview.net, 2019.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017.
+
+Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 32, 2020.
+
+Jonathan Ho, Chitwan Saharia, William Chan, David J. Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. J. Mach. Learn. Res., 23, 2022.
+
+Alexia Jolicoeur-Martineau, Remi Pich ´ e-Taillefer, Ioannis Mitliagkas, and Remi Tachet des ´ Combes. Adversarial score matching and improved sampling for image generation. International Conference on Learning Representations, 2021.
+
+Zahra Kadkhodaie and Eero Simoncelli. Stochastic solutions for linear inverse problems using the prior implicit in a denoiser. Advances in Neural Information Processing Systems, 34, 2021.
+
+Tero Karras, Miika Aittala, Timo Aila, and Samuli Laine. Elucidating the design space of diffusionbased generative models. arXiv preprint arXiv:2206.00364, 2022.
+
+Bahjat Kawar, Gregory Vaksman, and Michael Elad. Stochastic image denoising by sampling from the posterior distribution. International Conference on Computer Vision Workshops, 2021.
+
+Bahjat Kawar, Michael Elad, Stefano Ermon, and Jiaming Song. Denoising diffusion restoration models. arXiv preprint arXiv:2201.11793, 2022.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P. Kingma, Tim Salimans, Ben Poole, and Jonathan Ho. On density estimation with diffusion models. Advances in Neural Information Processing Systems, 34, 2021.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to´ document recognition. Proc. IEEE, 86(11):2278–2324, 1998.
+
+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.
+
+Christopher A. Metzler, Ali Mousavi, and Richard G. Baraniuk. Learned D-AMP: principled neural network based compressive image recovery. Advances in Neural Information Processing Systems, 30, 2017.
+
+Alexander Quinn Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. In Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 8162–8171, 2021.
+
+Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical textconditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.
+
+Severi Rissanen, Markus Heinonen, and Arno Solin. Generative modelling with inverse heat dissipation. arXiv preprint arXiv:2206.13397, 2022.
+
+Yaniv Romano, Michael Elad, and Peyman Milanfar. The little engine that could: Regularization by denoising (RED). arXiv preprint arXiv:1611.02862, 2016.
+
+Chitwan Saharia, Jonathan Ho, William Chan, Tim Salimans, David J. Fleet, and Mohammad Norouzi. Image super-resolution via iterative refinement. arXiv preprint arXiv:2104.07636, 2021.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems, 29, 2016.
+
+Jascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, volume 37 of JMLR Workshop and Conference Proceedings, 2015.
+
+Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. International Conference on Learning Representations, 2021a.
+
+Yang Song and Stefano Ermon. Generative modeling by estimating gradients of the data distribution. Advances in Neural Information Processing Systems, 32, 2019.
+
+Yang Song, Jascha Sohl-Dickstein, Diederik P. Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. International Conference on Learning Representations, 2021b.
+
+Jay Whang, Mauricio Delbracio, Hossein Talebi, Chitwan Saharia, Alexandros G. Dimakis, and Peyman Milanfar. Deblurring via stochastic refinement. arXiv preprint arXiv:2112.02475, 2021.
+
+# A APPENDIX
+
+# A.1 DEBLURRING
+
+For the deblurring experiments, we train the models on different datasets for 700,000 gradient steps. We use the Adam (Kingma & Ba, 2014) optimizer with learning rate $2 \times 1 0 ^ { - 5 }$ . The training was done on the batch size of 32, and we accumulate the gradients every 2 steps. Our final model is an Exponential Moving Average of the trained model with decay rate 0.995 which is updated after every 10 gradient steps.
+
+For the MNIST dataset, we blur recursively 40 times, with a discrete Gaussian kernel of size 11x11 and a standard deviation 7. In the case of CIFAR-10, we recursively blur with a Gaussian kernel of fixed size 11x11, but at each step $t$ , the standard deviation of the Gaussian kernel is given by $0 . 0 1 * t + 0 . 3 5$ . The blur routine for CelebA dataset involves blurring images with a Gaussian kernel of 15x15 and the standard deviation of the Gaussian kernel grows exponentially with time $t$ at the rate of 0.01.
+
+![](images/e7c9f69965cce37cedf756203a0cae3d185a6edddcf11b8b33e43ecb79bf8c3e.jpg)  
+Figure 9 shows an additional nine images for each of MNIST, CIFAR-10 and CelebA. Figures 19 and 20 show the iterative sampling process using a deblurring model for ten example images from each dataset. We further show 400 random images to demonstrate the qualitative results in the Figure 21.   
+Figure 9: Additional examples from deblurring models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+# A.2 INPAINTING
+
+For the inpainting transformation, models were trained on different datasets with 60,000 gradient steps. The models were trained using Adam (Kingma & Ba, 2014) optimizer with learning rate $2 \times$ $1 0 ^ { \div { 5 } }$ . We use batch size 64, and the gradients are accumulated after every 2 steps. The final model is an Exponential Moving Average of the trained model with decay rate 0.995. This EMA model is updated after every 10 gradient steps. For all our inpainting experiments we use a randomized Gaussian mask and $T = 5 0$ with $\beta _ { 1 } = 1$ and $\beta _ { i + 1 } = \beta _ { i } + 0 . 1$ .
+
+To avoid potential leakage of information due to floating point computation of the Gaussian mask, we discretize the masked image before passing it through the inpainting model. This was done by rounding all pixel values to the eight most significant digits.
+
+Figure 11 shows nine additional inpainting examples on each of the MNIST, CIFAR-10, and CelebA datasets. Figure 10 demonstrates an example of the iterative sampling process of an inpainting model for one image in each dataset.
+
+# A.3 SUPER-RESOLUTION
+
+We train the super-resolution model per Section 3.1 for 700,000 iterations. We use the Adam (Kingma & Ba, 2014) optimizer with learning rate $2 \times 1 0 ^ { - 5 }$ . The batch size is 32, and we accumulate the gradients every 2 steps. Our final model is an Exponential Moving Average of the trained model with decay rate 0.995. We update the EMA model every 10 gradient steps.
+
+The number of time-steps depends on the size of the input image and the final image. For MNIST and for CIFAR10, the number of time steps is 3, as it takes three steps of halving the resolution to reduce the initial image down to $4 \times 4$ . For CelebA, the number of time steps is 6 to reduce the initial image down to $2 \times 2$ . For CIFAR10, we apply random crop and random horizontal flip for regularization.
+
+Figure 13 shows an additional nine super-resolution examples on each of the MNIST, CIFAR-10, and CelebA datasets. Figure 12 shows one example of the progressive increase in resolution achieved with the sampling process using a super-resolution model for each dataset.
+
+# A.4 COLORIZATION
+
+Here we provide results for the additional task of colorization. Starting with the original RGBimage $x _ { 0 }$ , we realize colorization by iteratively desaturating for $T$ steps until the final image $x _ { T }$ is a fully gray-scale image. We use a series of three-channel $1 \times 1$ convolution filters ${ \mathbf z } ( \alpha ) \ : = \ : $ $\{ z ^ { 1 } ( \alpha ) , \bar { z } ^ { 2 } ( \alpha ) , z ^ { 3 } ( \alpha ) \}$ with the form
+
+$$
+\begin{array} { c } { { z ^ { 1 } ( \alpha ) = \alpha \left( \frac 1 3 \frac 1 3 \frac 1 3 \right) + \left( 1 - \alpha \right) ( 1 0 0 ) } } \\ { { z ^ { 2 } ( \alpha ) = \alpha \left( \frac 1 3 \frac 1 3 \frac 1 3 \right) + ( 1 - \alpha ) ( 0 1 0 ) } } \\ { { z ^ { 3 } ( \alpha ) = \alpha \left( \frac 1 3 \frac 1 3 \frac 1 3 \right) + ( 1 - \alpha ) ( 0 0 1 ) } } \end{array}
+$$
+
+and obtain $D ( x , t ) = \mathbf { z } ( \alpha _ { t } ) * x$ via a schedule defined as $\alpha _ { 1 } , \ldots , \alpha _ { t }$ for each respective step. Notice that a gray image is obtained when $x _ { T } = { \bf z } ( 1 ) * x _ { 0 }$ .
+
+We can tune the ratio $\alpha _ { t }$ to control the amount of information removed in each step. For our experiment, we schedule the ratio such that for every $t$ we have
+
+$$
+x _ { t } = \mathbf { z } ( \alpha _ { t } ) * \ldots * \mathbf { z } ( \alpha _ { 1 } ) * x _ { 0 } = \mathbf { z } ( \frac { t } { T } ) * x _ { 0 } .
+$$
+
+This schedule ensures that color information lost between steps is smaller in earlier stage of the diffusion and becomes larger as $t$ increases.
+
+We train the models on different datasets for 700,000 gradient steps. We use Adam (Kingma & Ba, 2014) optimizer with learning rate $2 \times 1 0 ^ { - 5 }$ . We use batch size 32, and we accumulate the gradients every 2 steps. Our final model is an exponential moving average of the trained model with decay rate 0.995. We update the EMA model every 10 gradient steps. For CIFAR-10 we use $T = 5 0$ and for CelebA we use $T = 2 0$ .
+
+![](images/53fae5179cd767d845061739046119c2c525e23ec5c815c25a269ff29ab65298.jpg)  
+Figure 10: Progressive inpainting of selected masked MNIST, CIFAR-10, and CelebA images.
+
+![](images/5f686abf312883354851ccde77329612aee7401ccec462ab076a03867f2c53d4.jpg)  
+Figure 11: Additional examples from inpainting models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+![](images/d2e7b9f06cc69adeffb543b92fef72968d86afdb115f11deee8b28ba91d749b6.jpg)  
+Figure 12: Progressive upsampling of selected downsampled MNIST, CIFAR-10, and CelebA images. The original image is at the left for each of these progressive upsamplings.
+
+We illustrate our recolorization results in Figure 14. We present testing examples, as well as their grey scale images, from all the datasets, and compare the recolorization results with the original images. The recolored images feature correct color separation between different regions, and feature various and yet semantically correct colorization of objects. Our sampling technique still yields minor differences in comparison to the direct reconstruction, although the change is not visually apparent. We attribute this to the shape restriction of colorization task, as human perception is rather insensitive to minor color change. We also provide quantitative measurement for the effectiveness of our recolorization results in terms of different similarity metrics, and summarize the results in Table 6.
+
+Table 6: Quantitative metrics for quality of image reconstruction using recolorization models for all three channel datasets.   
+
+<table><tr><td></td><td colspan="3">Degraded Image</td><td colspan="3">Reconstruction</td></tr><tr><td>Dataset</td><td>FID</td><td>SSIM</td><td>RMSE</td><td>FID</td><td>SSIM</td><td>RMSE</td></tr><tr><td>CIFAR-10</td><td>97.39</td><td>0.937</td><td>0.078</td><td>45.74</td><td>0.942</td><td>0.069</td></tr><tr><td>CelebA</td><td>41.20</td><td>0.942</td><td>0.089</td><td>17.50</td><td>0.973</td><td>0.042</td></tr></table>
+
+![](images/846887c5faa76e942eceed002cdd2dd7b3b19582b59455cf20a6b83a0e6de3b5.jpg)  
+Figure 13: Additional examples from super-resolution models trained on the MNIST, CIFAR-10, and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+![](images/2b6a3edfc403cc24c01705384baef83b7ef5843fc6f94a63c621993cd684b2b6.jpg)  
+Figure 14: Recolorization models trained on the CIFAR-10 and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+# A.5 IMAGE SNOW
+
+Here we provide results for the additional task of snowification, which is a direct adaptation of the offical implementation of ImageNet-C snowification process (Hendrycks & Dietterich, 2019). To determine the snow pattern of a given image $\boldsymbol { x } _ { 0 } \in \mathbb { R } ^ { \boldsymbol { \dot { C } } \times \boldsymbol { H } \times \boldsymbol { W } }$ , we first construct a seed matrix $S _ { A } \in \mathbb { R } ^ { H \times W }$ where each entry is sampled from a Gaussian distribution $N ( \mu , \sigma )$ . The upper-left corner of $S _ { A }$ is then zoomed into another matrix $S _ { B } \in \mathbb { R } ^ { H \times W }$ with spline interpolation. Next, we create a new matrix $S _ { C }$ by filtering each value of $S _ { B }$ with a given threshold $c _ { 1 }$ as
+
+$$
+\begin{array} { r } { S _ { C } [ i ] [ j ] = \left\{ \begin{array} { l l } { 0 , } & { S _ { B } [ i ] [ j ] \le c _ { 1 } } \\ { S _ { B } [ i ] [ j ] , } & { S _ { B } [ i ] [ j ] > c _ { 1 } } \end{array} \right. } \end{array}
+$$
+
+and clip each entry of $S _ { C }$ into the range $[ 0 , 1 ]$ . We then convolve $S _ { C }$ using a motion blur kernel with standard deviation $c _ { 2 }$ to create the snow pattern $S$ and its up-side-down rotation $S ^ { \prime }$ . The direction of the motional blur kernel is randomly chosen as either vertical or horizontal. The final snow image is created by again clipping each value of $x _ { 0 } + S + S ^ { \prime }$ into the range $[ 0 , 1 ]$ . For simplicity, we abstract the process as a function $h ( x _ { 0 } , S _ { A } , c _ { 0 } , c _ { 1 } )$ .
+
+![](images/f30af456b4ed5d4abfa1bd8cbfc1059a259f3fd1b4460746498cb077083b14bd.jpg)  
+Figure 15: Additional examples from Desnowification models trained on the CIFAR-10 and CelebA datasets. Left to right: degraded inputs $D ( x _ { 0 } , T )$ , direct reconstruction $R ( D ( x _ { 0 } , T ) )$ , sampled reconstruction with TACoS described in Algorithm 2, and original image.
+
+To create a series of between $[ c _ { 0 } ^ { \mathrm { s t a r t } } , c _ { 0 } ^ { \mathrm { e n d } } ]$ and $T$ images with increasing snowification, we linearly interpolate $[ c _ { 1 } ^ { \mathrm { s t a r f } } , c _ { 1 } ^ { \mathrm { e n d } } ]$ respectively, to create $c _ { 0 } ( t )$ and $c _ { 1 } ( t )$ , $t = 1 , \dots , T$ . Then for $c _ { 0 }$ and $c _ { 1 }$ each $x _ { 0 }$ , a seed matrix $S _ { x }$ is sampled, the motion blur direction is randomized, and we construct each related $x _ { t }$ by $x _ { t } = h ( x _ { 0 } , S _ { x } , c _ { 0 } ( t ) , c _ { 1 } ( t ) )$ . Visually, $c _ { 0 } ( t )$ dictates the severity of the snow, while $c _ { 1 } ( t )$ determines how “windy” the snowified image seems.
+
+For both CIFAR-10 and Celeb-A, we use the same Gaussian distribution with parameters $\mu = 0 . 5 5$ and $\sigma = 0 . 3$ to generate the seed matrix. For CIFAR-10, we choose $c _ { 0 } ^ { \mathrm { s t a r t } } = 1 . 1 5$ , $c _ { 0 } ^ { \mathrm { e n d } } = 0 . 7$ , $c _ { 1 } ^ { \mathrm { s t a r t } } = 0 . 0 5$ and $c _ { 1 } ^ { \mathrm { e n d } } = 1 6$ 0 0 , which generates a visually lighter snow. For Celeb-A, we choose $c _ { 0 } ^ { \mathrm { s t a r t } } = 1 . 1 5$ , $c _ { 0 } ^ { \mathrm { e n d } } = 0 . 5 5$ , $c _ { 1 } ^ { \mathrm { s t a r t } } = 0 . 0 5$ and $c _ { 1 } ^ { \mathrm { e n d } } = 2 0 $ , which generates a visually heavier snow.
+
+We train the models on different datasets for 700,000 gradient steps. We use Adam (Kingma & Ba, 2014) optimizer with learning rate $2 \times 1 0 ^ { - 5 }$ . We use batch size 32, and we accumulate the gradients every 2 steps. Our final model is an exponential moving average of the trained model with decay rate 0.995. We update the EMA model every 10 gradient steps. For CIFAR-10 we use $T = 2 0 0$ and for CelebA we use $T = 2 0 0$ . We note that the seed matrix is resampled for each individual training batch, and hence the snow pattern varies across the training stage.
+
+# A.6 GENERATION USING NOISE : FURTHER DETAILS
+
+Here we show the equivalence between the sampling method proposed in Algorithm 2 and the deterministic sampling in DDIM (Song et al., 2021a). Given the image $x _ { t }$ at step $t$ , we have the restored clean image $\hat { x _ { 0 } }$ from the diffusion model. Hence given the estimated $\hat { x _ { 0 } }$ and $x _ { t }$ , we can estimate the noise $z ( x _ { t } , t )$ (or $\hat { z }$ ) as
+
+$$
+z ( x _ { t } , t ) = \frac { x _ { t } - \sqrt { \alpha _ { t } } \hat { x _ { 0 } } } { \sqrt { 1 - \alpha _ { t } } } ,
+$$
+
+Thus, the $D ( \hat { x _ { 0 } } , t )$ and $D ( \hat { x _ { 0 } } , t - 1 )$ can be written as
+
+$$
+D ( \hat { x _ { 0 } } , t ) = \sqrt { \alpha _ { t } } \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t } } \hat { z } ,
+$$
+
+$$
+D ( \hat { x _ { 0 } } , t - 1 ) = \sqrt { \alpha _ { t - 1 } } \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t - 1 } } \hat { z } ,
+$$
+
+using which the sampling process in Algorithm 2 to estimate $x _ { t - 1 }$ can be written as,
+
+$$
+\begin{array} { r l } & { x _ { t - 1 } = x _ { t } - D ( \hat { x _ { 0 } } , t ) + D ( \hat { x _ { 0 } } , t - 1 ) } \\ & { \qquad = x _ { t } - \big ( \sqrt { \alpha _ { t } } \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t } } \hat { z } \big ) + \big ( \sqrt { \alpha _ { t - 1 } } \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t - 1 } } \hat { z } \big ) } \\ & { \qquad = \sqrt { \alpha _ { t - 1 } } \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t - 1 } } \hat { z } } \end{array}
+$$
+
+which is same as the sampling method as described in (Song et al., 2021a). The only difference from the original (Song et al., 2021a) is the order for estimating $\hat { x _ { 0 } }$ and $\hat { z }$ . The original (Song et al., 2021a) paper estimated $\hat { z }$ first and then used this to predict clean image $\hat { x _ { 0 } }$ , while we first predict the clean image $\hat { x _ { 0 } }$ and then estimate the noise $\hat { z }$ .
+
+# A.7 GENERATION USING BLUR TRANSFORMATION: FURTHER DETAILS
+
+![](images/dfee8095b19fe3b0976b64ba7e12c3fd7b97f27893230026285cd327a150f728.jpg)  
+Figure 16: Examples of generated samples from $1 2 8 \times 1 2 8$ CelebA and AFHQ datasets using Method 2 with perfect symmetry.
+
+The Figure 16, shows the generation without breaking any symmetry within each channel are quite promising as well.
+
+Necessity of Algorithm 2: In the case of unconditional generation, we observe a marked superiority in quality of the sampled reconstruction using Algorithm 2 over any other method considered. For example, in the broken symmetry case, the FID of the directly reconstructed images is 257.69 for CelebA and 214.24 for AFHQ, which are far worse than the scores of 49.45 and 54.68 from Table 5. In Figure 17, we also give a qualitative comparison of this difference. We can also clearly see from Figure 18 that Algorithm 1, the method used in Song et al. (2021b) and Ho et al. (2020), completely fails to produce an image close to the target data distribution.
+
+# A.8 ALGORITHM 1 IS SAME AS DDIM/DDPM SAMPLING
+
+The sampling method proposed in Song et al. (2021a) in it’s equation 12 is given as
+
+$$
+x _ { t - 1 } = \sqrt { \alpha _ { t - 1 } } \cdot \mathrm { \ " { s p r e d i c t e d } } x _ { 0 } \mathrm { \ " { ~ , ~ } } + \sqrt { 1 - \alpha _ { t - 1 } - \sigma _ { t } ^ { 2 } } \epsilon _ { \theta } ( x _ { t } ) + \sigma _ { t } \epsilon _ { t }
+$$
+
+where $\epsilon _ { \theta } ( x _ { t } )$ is the noise predicted by the diffusion model given $x _ { t }$ and $t$ . The term “predicted $x _ { 0 }$ ” or $\hat { x _ { 0 } }$ can be computed directly given $x _ { t }$ and $\epsilon _ { \theta } ( x _ { t } )$ as
+
+$$
+\hat { x _ { 0 } } = \frac { x _ { t } - \sqrt { 1 - \alpha _ { t } } \epsilon _ { \theta } ( x _ { t } ) } { \sqrt { \alpha _ { t } } } ,
+$$
+
+Hence using $\hat { z }$ instead of $\epsilon _ { \theta } ( x _ { t } )$ and $\hat { x _ { 0 } }$ to indicate predicted clean image, we have
+
+$$
+x _ { t - 1 } = \sqrt { \alpha _ { t - 1 } } \cdot \hat { x _ { 0 } } + \sqrt { 1 - \alpha _ { t - 1 } - \sigma _ { t } ^ { 2 } } \hat { z } + \sigma _ { t } \epsilon _ { t }
+$$
+
+Thus, the sampling step can interpreted as follows: At each step $t$ , we start with a noisy image $x _ { t }$ and use the diffusion model to estimate the clean image $\hat { x _ { 0 } }$ and the noise $\hat { z }$ that was added to this clean image $\hat { x _ { 0 } }$ to get the noisy image $x _ { t }$ . In order to move to lesser noisy image $x _ { t - 1 }$ , one “adds back” lesser noise to the the “predicted clean image” $\hat { x _ { 0 } }$ . Now one can add back noise in 2 ways, either the noise which was added to the clean image $\hat { x _ { 0 } }$ which is $\hat { z }$ or sample a new uncorrelated noise $\epsilon _ { t }$ . Infact both of these noise can be added using $\sigma _ { t }$ as the hyperparameter that weighs the amount of each noise added. This $\sigma _ { t }$ is placed in the equation such that for any choice of $\sigma _ { t }$ , the standard deviation of noise added back is $\sqrt { 1 - \alpha _ { t - 1 } }$ . For $\sigma _ { t } = 0$ , we only add back the estimated noise $\hat { z }$ and no uncorrelated noise $\epsilon _ { t }$ which is infact the DDIM sampling. While for $\sigma _ { t } = \sqrt { ( 1 - \alpha _ { t - 1 } ) / ( 1 - \alpha _ { t } ) } \sqrt { 1 - \alpha _ { t } / \alpha _ { t - 1 } }$ we get the sampling method described in DDPM.
+
+Nevertheless, for any choice of $\sigma _ { t }$ , the sampling method involves a denoising operation which is shown as $R ( x _ { s } , s )$ in Algorithm 1 and adding back noise shown as $x _ { s - 1 } = D ( \hat { x _ { 0 } } , s - 1 )$ in Algorithm 1. The only difference between different sampling methods explained in DDPM or DDIM is how one degrades the image back.
+
+![](images/715394f6dca04c49b937c458e0674dced6f73c4fe2f2c72febfc67bb2c928a9d.jpg)  
+Figure 17: Comparison of direct reconstruction with sampling using TACoS described in Algorithm 2 for generation with blur transformation and broken symmetry. Left-hand column is the initial cold images generated using the simple Gaussian model. Middle column has images generated in one step (i.e. direct reconstruction). Right-hand column are the images sampled with TACoS described in Algorithm 2. We present results for both CelebA (top) and AFHQ (bottom) with resolution $1 2 8 \times 1 2 8$ .
+
+![](images/e2f5864ab2e4307ab324bd5169b528dc972ea8470193602a66f166bb9bbe2e75.jpg)  
+Figure 18: Comparison of Algorithm 1 (top row) and Algorithm 2 (bottom row) for generation with Method 2 and broken symmetry on $1 2 8 \times 1 2 8$ CelebA dataset. We demonstrate that Algorithm 1 fails completely to generate a new image.
+
+![](images/b8d77482ec10a2dca472bf79cf6526912ed04869e58a7fd4f0da9d4dd2518df7.jpg)  
+Figure 19: Progressive deblurring of selected blurred MNIST and CIFAR-10 images.
+
+![](images/dd271833367bac55d74ac0cd8e55ce90524e1c9d12715110ae0704f55f99b752.jpg)  
+Figure 20: Progressive deblurring of selected blurred CelebA images.
+
+![](images/62d99ee7ed2f1b6dff74a4f9426c4c2305b8c46d3cfe064eceac7d6e81ccd810.jpg)  
+Figure 21: Deblurred Cifar10 images

parse/dev/wqD6TfbYkrn/wqD6TfbYkrn.md

@@ -0,0 +1,403 @@
+# A CONDITIONAL POINT DIFFUSION-REFINEMENTPARADIGM FOR 3D POINT CLOUD COMPLETION
+
+Zhaoyang Lyu1,2∗ Zhifeng Kong3∗ Xudong $\mathbf { X } \mathbf { u } ^ { 1 }$ Liang Pan4 Dahua Lin1,2 1CUHK-SenseTime Joint Lab, The Chinese University of Hong Kong 2Shanghai AI Laboratory 3University of California, San Diego $^ 4 { \cal S }$ -Lab, Nanyang Technological University lyuzhaoyang@link.cuhk.edu.hk, z4kong@eng.ucsd.edu   
+xx018@ie.cuhk.edu.hk, liang.pan@ntu.edu.sg, dhlin@ie.cuhk.edu.hk
+
+# ABSTRACT
+
+3D point cloud is an important 3D representation for capturing real world 3D objects. However, real-scanned 3D point clouds are often incomplete, and it is important to recover complete point clouds for downstream applications. Most existing point cloud completion methods use Chamfer Distance (CD) loss for training. The CD loss estimates correspondences between two point clouds by searching nearest neighbors, which does not capture the overall point density distribution on the generated shape, and therefore likely leads to non-uniform point cloud generation. To tackle this problem, we propose a novel Point Diffusion-Refinement (PDR) paradigm for point cloud completion. PDR consists of a Conditional Generation Network (CGNet) and a ReFinement Network (RFNet). The CGNet uses a conditional generative model called the denoising diffusion probabilistic model (DDPM) to generate a coarse completion conditioned on the partial observation. DDPM establishes a one-to-one pointwise mapping between the generated point cloud and the uniform ground truth, and then optimizes the mean squared error loss to realize uniform generation. The RFNet refines the coarse output of the CGNet and further improves quality of the completed point cloud. Furthermore, we develop a novel dual-path architecture for both networks. The architecture can (1) effectively and efficiently extract multi-level features from partially observed point clouds to guide completion, and (2) accurately manipulate spatial locations of 3D points to obtain smooth surfaces and sharp details. Extensive experimental results on various benchmark datasets show that our PDR paradigm outperforms previous state-of-the-art methods for point cloud completion. Remarkably, with the help of the RFNet, we can accelerate the iterative generation process of the DDPM by up to 50 times without much performance drop.
+
+# 1 INTRODUCTION
+
+With the rapid developments of 3D sensors, 3D point clouds are an important data format that captures 3D information owing to their ease of acquisition and efficiency in storage. Unfortunately, point clouds scanned in the real world are often incomplete due to partial observation and self occlusion. It is important to recover the complete shape by inferring the missing parts for many downstream tasks such as 3D reconstruction, augmented reality and scene understanding. To tackle this problem, many learning-based methods (Yuan et al., 2018; Yang et al., 2018; Tchapmi et al., 2019; Xie et al., 2020; Liu et al., 2020; Pan et al., 2021) are proposed, which are supervised by using either the Chamfer Distance (CD) or Earth Mover Distance (EMD) to penalize the discrepancies between the generated complete point cloud and the ground truth. However, CD loss is not sensitive to overall density distribution, and thus networks trained by CD loss could generate non-uniform point cloud completion results (See Figure 10 and 11 in Appendix). EMD is more distinctive to measure density distributions, but it is too expensive to compute in training. The absence of an effective and efficient training loss highly limits the capabilities of many existing point cloud completion networks.
+
+![](images/628f32b0f4671d2e01a65c2fadda5b4b05cab621f6a83ec5503931cdb9cd9155.jpg)  
+Figure 1: Our Conditional Point Diffusion-Refinement (PDR) paradigm first moves a Gaussian noise step by step towards a coarse completion of the partial observation through a diffusion model (DDPM). Then it refines the coarse point cloud by one step to obtain a high quality point cloud.
+
+We find that denoising diffusion probabilistic models (DDPM) (Sohl-Dickstein et al., 2015; Ho et al., 2020) can potentially generate uniform and high quality point clouds with an effective and efficient loss function. It can iteratively move a set of Gaussian noise towards a complete and clean point cloud. DDPM defines a one-to-one pointwise mapping between two consecutive point clouds in the diffusion process, which enables it to use a simple mean squared error loss function for training. This loss function is efficient to compute and explicitly requires the generated point cloud to be uniform, as a one-to-one point mapping is naturally established between the generated point cloud and the ground truth. Point cloud completion task can be treated as a conditional generation problem in the framework of DDPM (Zhou et al., 2021; Luo & Hu, 2021). Indeed, we find the complete point clouds generated by a conditional DDPM often have a good overall distribution that uniformly covers the shape of the object.
+
+Nonetheless, due to the probabilistic nature of DDPM and the lack of a suitable network architecture to train the conditional DDPM for 3D point cloud completion in previous works, we find DDPM completed point clouds often lack smooth surfaces and sharp details (See Figure 1 and Appendix Figure 12), which is also reflected by their high CD loss compared with state-of-the-art point cloud completion methods in our experiments. Another problem with DDPM is its inefficiency in the inference phase. It usually takes several hundreds and even up to one thousand forward steps to generate a single point cloud. Several methods (Song et al., 2020; Nichol & Dhariwal, 2021; Kong & Ping, 2021) are proposed to accelerate DDPM using jumping steps without retraining networks, which however, leads to an obvious performance drop when using a small number of diffusion steps.
+
+In this work, we propose the Conditional Point Diffusion-Refinement (PDR) paradigm to generate both uniform and high quality complete point clouds. As shown in Figure 1, our PDR paradigm performs point cloud completion in a coarse-to-fine fashion. Firstly, we use the Conditional Generation Network (CGNet) to generate a coarse complete point cloud by the DDPM conditioned on the partial point cloud. It iteratively moves a set of Gaussian noise towards a complete point cloud. Following, the ReFinement Network (RFNet) further refines the coarse complete point cloud generated from the Conditional Generation Network with the help of partial point clouds. In addition, RFNet can be used to refine the low quality point clouds generated by an accelerated DDPM, so that we could enjoy an acceleration up to 50 times, while minimizing the performance drop. In this way, the completion results generated by our PDR paradigm demonstrate both good overall density distribution (i.e. uniform) and sharp local details.
+
+Both CGNet and RFNet have a novel dual-path network architecture shown in Figure 2, which is composed of two parallel sub-networks, a Denoise subnet and a Condition Feature Extraction subnet for noisy point clouds and partial point clouds, respectively. Specifically, we propose Point Adaptive Deconvolution (PA-Deconv) operation for upsampling, which can effectively manipulate spatial locations of 3D points. Furthermore, we propose the Feature Transfer (FT) module to directly transmit encoded point features at different scales from the Condition Feature Extraction subnet to the corresponding hierarchy in the Denoise subnet. Extensive experimental results show that our PDR paradigm can provide new state-of-the-art performance for point cloud completion.
+
+Our Key contributions can be summarized as: 1) We identify conditional DDPM to be a good model with an effective and efficient loss function to generate uniform point clouds in point cloud completion task. 2) By using RFNet to refine the coarse point clouds, our PDR paradigm can generate complete point cloud with both good overall density distribution (i.e. uniform) and sharp local details. 3) We design novel point learning modules, including PA-Deconv and Feature Transfer modules, for constructing CGNet in DDPM and RFNet, which effectively and efficiently utilizes multi-level features extracted from incomplete point clouds for point cloud completion. 4) With the help of our proposed RFNet, we can accelerate the generation process of DDPM up to 50 times without a significant drop in point cloud quality.
+
+![](images/002d4532dd55eabda2053e09d84cc1480c88db3fec7d0555278e1e2def56a2c3.jpg)  
+Figure 2: Network architecture of the Conditional Generation Network (CGNet) and ReFinement Network (RFNet). It consists of the Condition Feature Extraction subnet and the Denoise subnet.
+
+# 2 PROBLEM STATEMENT
+
+In this paper, we focus on the 3D point cloud completion task. A 3D point cloud is represented by $N$ points in the 3D space: $X = \{ x _ { j } | 1 \leq j \leq N \}$ , where each $x _ { j } \in \mathbb { R } ^ { \hat { 3 } }$ is the 3D coordinates of the $j$ -th point. We assume the dataset is composed of $M$ data pairs $\mathsf { \bar { \{ } }  ( X _ { i } , C _ { i } ) | 1 \leq i \leq M \}$ , where $X _ { i }$ is the $i$ -th ground-truth point cloud, and $C _ { i }$ is the incomplete point cloud from a partial observation of $X _ { i }$ . The goal is to develop a model that completes the partial observation $C _ { i }$ and outputs a point cloud as close to the ground truth $X _ { i }$ as possible. For algebraic convenience, we let $\pmb { x } \in \mathbb { R } ^ { 3 N }$ be the vector form of a point cloud $\boldsymbol { X }$ , and similarly $^ c$ be the vector form of $C$ .
+
+# 3 METHODOLOGY
+
+We consider the point cloud completion task as a conditional generation problem, where the incomplete point cloud $C$ serves as the conditioner. We use the powerful generative model called denoising diffusion probabilistic models (DDPM) (Sohl-Dickstein et al., 2015; Ho et al., 2020; Kong et al., 2020) to first generate a coarse completion of the partial observation. Then we use another network to refine the coarse point cloud to improve its visual quality. Our point cloud completion pipeline is shown in Figure 1. We first briefly introduce the theory of DDPM in Section 3.1, and then describe detailed architecture of the Conditional Generation Network (CGNet) and ReFinement Network (RFNet) in Section 3.2 and Section 3.3.
+
+# 3.1 BACKGROUND ON CONDITIONAL DENOISING DIFFUSION PROBABILISTIC MODELS
+
+We assume $p _ { \mathrm { d a t a } }$ to be the distribution of the complete point cloud $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ in the dataset, and $p _ { \mathrm { l a t e n t } } =$ $\mathcal { N } ( \mathbf { 0 } _ { 3 N } , I _ { 3 N \times 3 N } )$ to be the latent distribution, where $\mathcal { N }$ is the Gaussian distribution. Then, the conditional DDPM consists of two Markov chains called the diffusion process and the reverse process. Both processes have length equal to $T$ . We set $T = 1 0 0 0$ in this paper.
+
+The Diffusion Process. The diffusion process is a Markov process that adds Gaussian noise into the clean data distribution $p _ { \mathrm { d a t a } }$ until the output distribution is close to $p _ { \mathrm { l a t e n t } }$ . The diffusion process is irrelevant of the conditioner, the incomplete point cloud $c _ { i }$ . Formally, let $\mathbf { \boldsymbol { x } } ^ { 0 } \sim p _ { \mathrm { d a t a } }$ . We use the superscript to denote the diffusion step $t$ . For conciseness, we omit the subscription $i$ in the following discussion. The diffusion process from clean data $\mathbf { \boldsymbol { x } } ^ { 0 }$ to $\mathbf { x } ^ { T }$ is defined as
+
+$$
+q ( \pmb { x } ^ { 1 } , \cdots , \pmb { x } ^ { T } | \pmb { x } ^ { 0 } ) = \prod _ { t = 1 } ^ { T } q ( \pmb { x } ^ { t } | \pmb { x } ^ { t - 1 } ) , \mathrm { ~ w h e r e ~ } q ( \pmb { x } ^ { t } | \pmb { x } ^ { t - 1 } ) = \mathcal { N } ( \pmb { x } ^ { t } ; \sqrt { 1 - \beta _ { t } } \pmb { x } ^ { t - 1 } , \beta _ { t } I ) .
+$$
+
+The hyperparameters $\beta _ { t }$ are pre-defined, small positive constants (See details in Appendix Section A.1). According to Ho et al. (2020), there is a closed form expression for $q ( \pmb { x } ^ { t } | \pmb { x } ^ { 0 } )$ . We first define constants $\alpha _ { t } = 1 - \beta _ { t }$ , $\begin{array} { r } { \bar { \alpha } _ { t } = \prod _ { i = 1 } ^ { t } \alpha _ { i } } \end{array}$ . Then, we have ${ q ( { \pmb x } ^ { t } | { \pmb x } ^ { 0 } ) = \mathcal { N } \left( { \pmb x } ^ { t } ; \sqrt { { \bar { \alpha } } _ { t } } { \pmb x } ^ { 0 } , ( 1 - { \bar { \alpha } } _ { t } ) { \pmb I } \right) }$ .
+
+Therefore, when $T$ is large enough, $\bar { \alpha } _ { t }$ goes to 0, and $q ( \pmb { x } ^ { T } | \pmb { x } ^ { 0 } )$ becomes close to the latent distribution $p _ { \mathrm { l a t e n t } } ( \pmb { x } ^ { T } )$ . Note that $\mathbf { \boldsymbol { x } } ^ { t }$ can be directly sampled through the following equation:
+
+${ \pmb x } ^ { t } = \sqrt { \bar { \alpha } _ { t } } { \pmb x } ^ { 0 } + \sqrt { 1 - \bar { \alpha } _ { t } } { \epsilon }$ , where $\epsilon$ is a standard Gaussian noise.
+
+We emphasize that $q ( \mathbf { \boldsymbol { x } } ^ { t } | \mathbf { \boldsymbol { x } } ^ { t - 1 } )$ can be seen as a one-to-one pointwise mapping as $\mathbf { \boldsymbol { x } } ^ { t }$ can be sampled through the equation $\pmb { x } ^ { t } = \sqrt { 1 - \beta _ { t } } \pmb { x } ^ { t - 1 } + \beta _ { t } \pmb { \epsilon }$ . Therefore, the order of points in $\pmb { x } ^ { 0 }$ is preserved in the diffusion process. However, it does not matter what kind of order we input the points in $\mathbf { \boldsymbol { x } } ^ { 0 }$ . That is because when $T$ is large enough, $\mathbf { \boldsymbol { x } } ^ { T }$ will become a Gaussian distribution. Every point in a Gaussian distribution is equivalent and there is no way to distinguish one point from another.
+
+The Reverse Process. The reverse process is a Markov process that predicts and eliminates the noise added in the diffusion process. The reverse process is conditioned on the conditioner, the incomplete point cloud $^ c$ . Let $\mathbf { \boldsymbol { x } } ^ { T } \sim p _ { \mathrm { l a t e n t } }$ be a latent variable. The reverse process from latent $\mathbf { \boldsymbol { x } } ^ { T }$ to clean data $\mathbf { \boldsymbol { x } } ^ { 0 }$ is defined as
+
+$$
+\ L _ { \theta } ( { \boldsymbol x } ^ { 0 } , \dots , { \boldsymbol x } ^ { T - 1 } | { \boldsymbol x } ^ { T } , c ) = \prod _ { t = 1 } ^ { T } p _ { \theta } ( { \boldsymbol x } ^ { t - 1 } | { \boldsymbol x } ^ { t } , c ) , { \mathrm { ~ w h e r e ~ } } p _ { \theta } ( { \boldsymbol x } ^ { t - 1 } | { \boldsymbol x } ^ { t } , c ) = \mathcal { N } ( { \boldsymbol x } ^ { t - 1 } ; \mu _ { \theta } ( { \boldsymbol x } ^ { t } , c , t ) , \sigma _ { t } ^ { 2 } I )
+$$
+
+The mean $\mu _ { \theta } ( \pmb { x } ^ { t } , \pmb { c } , t )$ is a neural network parameterized by $\pmb \theta$ and the variance $\sigma _ { t } ^ { 2 }$ is a time-step dependent constant. To generate a sample conditioned on $^ c$ , we first sample $\pmb { x } ^ { T } \sim \mathrm { \mathcal { N } } ( \mathbf { 0 } _ { 3 N } , \pmb { I } _ { 3 N \times 3 N } )$ , then draw $\pmb { x } ^ { t - 1 } \sim p _ { \pmb { \theta } } \bar { ( \pmb { x } ^ { t - 1 } | \pmb { x } ^ { t } , \pmb { c } ) }$ for $t = T , T - 1 , \cdots , 1$ , and finally outputs $\mathbf { \boldsymbol { x } } ^ { 0 }$ .
+
+Training. DDPM is trained via variational inference. Ho et al. (2020) introduced a certain parameterization for $\mu _ { \theta }$ that can largely simplify the training objective. The parameterization is $\begin{array} { r } { \sigma _ { t } ^ { 2 } \ = \ \frac { 1 - \bar { \alpha } _ { t - 1 } } { 1 - \bar { \alpha } _ { t } } \beta _ { t } } \end{array}$ 1−α¯t−11−α¯ βt, and µθ(xt, c, t) = $\begin{array} { r } { \mu _ { \theta } ( x ^ { t } , c , t ) ~ = ~ \frac { 1 } { \sqrt { \alpha _ { t } } } \left( x ^ { t } - \frac { \beta _ { t } } { \sqrt { 1 - \bar { \alpha } _ { t } } } \epsilon _ { \theta } ( x ^ { t } , c , t ) \right) } \end{array}$ , where $\epsilon _ { \theta }$ is a neural network taking noisy point cloud $\mathbf { \boldsymbol { x } } ^ { t } \sim q ( \mathbf { \boldsymbol { x } } ^ { t } | \mathbf { \boldsymbol { x } } ^ { 0 } )$ in equation (2), diffusion step $t$ , and conditioner $^ c$ as inputs. Then, the simplified training objective becomes
+
+$$
+{ \cal L } ( \pmb { \theta } ) = \mathbb { E } _ { i \sim { \mathcal { U } } ( [ M ] ) , t \sim { \mathcal { U } } ( [ T ] ) , \epsilon \sim { \mathcal { N } } ( 0 , I ) } \parallel \epsilon - \epsilon _ { \theta } \bigl ( \sqrt { \bar { \alpha } _ { t } } \pmb { x } _ { i } ^ { 0 } + \sqrt { 1 - \bar { \alpha } _ { t } } \epsilon , \pmb { c } _ { i } , t \bigr ) \parallel ^ { 2 } ,
+$$
+
+where $\mathcal { U } ( [ M ] )$ is the uniform distribution over $\{ 1 , 2 , \cdots , M \}$ . The neural network $\epsilon _ { \theta }$ learns to predict the noise $\epsilon$ added to the clean point cloud √ $\mathbf { \boldsymbol { x } } ^ { 0 }$ , which can be used to denoise the noisy point cloud $\pmb { x } ^ { t } = \sqrt { \bar { \alpha } _ { t } } \pmb { x } ^ { 0 } + \sqrt { 1 - \bar { \alpha } _ { t } } \epsilon$ . Note that traditional CD loss or EMD loss is NOT present in Equation 4. The reason that we are able to use the simple mean squared error is because DDPM naturally defines a one-to-one pointwise mapping between two consecutive point clouds in the diffusion process as shown in Equation 1. Note that at each training step, we not only need to sample a pair of point clouds ${ \mathbf { \mathit { x } } } _ { i } , { \mathbf { \mathit { c } } } _ { i }$ , but also a diffusion step $t$ and a Gaussian noise $\epsilon$ .
+
+# 3.2 CONDITIONAL GENERATION NETWORK
+
+In this section, we introduce the architecture of Conditional Generation Network (CGNet) $\epsilon _ { \theta }$ . The inputs of this network are the noisy point cloud $\mathbf { \boldsymbol { x } } ^ { t }$ , the incomplete point cloud $^ c$ , and the diffusion step $t$ . We can intuitively interpret the output of $\epsilon _ { \theta }$ as per-point difference between $\mathbf { \boldsymbol { x } } ^ { t }$ and ${ \pmb x } ^ { t - 1 }$ (with some arithmetic ignored). In addition, $\epsilon _ { \theta }$ should also effectively incorporate multi-level information from $^ c$ . The goal is to infer not only the overall shape but also the fine-grained details based on $^ c$ . We design a neural network that achieves these features. The overall architecture is shown in Figure 2. It is composed of two parallel sub-networks similar to PointNet+ $^ +$ (Qi et al., 2017b), and they have the same hierarchical structure.
+
+The upper subnet, which we refer as the Condition Feature Extraction subnet, extracts multi-level features from the incomplete point cloud $^ c$ . The lower subnet, which we refer as the Denoise subnet, takes the noisy point cloud $\mathbf { \boldsymbol { x } } ^ { t }$ as input. We also add the diffusion step $t$ , the global feature extracted from $^ c$ , and multi-level features extracted by the Condition Feature Extraction subnet to the Denoise subnet. The diffusion step $t$ is first transformed into a 512-dimension step embedding vector through positional encoding and fully connected (FC) layers (See Appendix Section A.1 for details), and then inserted to every level of the Denoise subnet. Similarly, the conditioner $^ c$ is first transformed into a 1024-length global feature through a two-stage PointNet, and then inserted to every level of the Denoise subnet. The multi-level features extracted by the Condition Feature Extraction subnet are inserted to every level of the Denoise subnet through Feature Transfer modules. Finally, the Denoise subnet is connected to a shared MLP and outputs $\bar { \mathbf { \Psi } } _ { \epsilon _ { \theta } ( \mathbf { \mathcal { x } } ^ { t } , c , t ) }$ .
+
+![](images/6f875b691a8ebf42c6f671ceeb602cfee8378328a3c2ee47303aac8f3d15bc6e.jpg)  
+Figure 3: (a) Insert information of the diffusion step embedding and the global feature to the shared MLP. (b) The Feature Transfer module maps features from the incomplete point cloud to the noisy point cloud. (c) Refine and upsample the coarse points at the same time.
+
+Additionally, while Zhou et al. (2021) argues PointNet $^ { + + }$ cannot be used in a DDPM that generates point clouds, we find attaching the absolute position of each point to its feature solves this problem. See Appendix Section A.3 for detailed analysis. We also improve the backbone PointNet+ $^ { \cdot + }$ so that it manipulates positions of points more accurately.
+
+In the next paragraphs, we elaborate on the building blocks of the improved PointNet+ $^ +$ : Set Abstraction modules in the encoder, and Feature Propagation modules in the decoder, and Feature Transfer modules between the Condition Feature Extraction subnet and the Denoise subnet.
+
+Set Abstraction (SA) Module. Similar to PointNet $^ { + + }$ , this module subsamples the input point cloud and propagates the input features. Assume the input is $\{ x _ { j } | 1 \le j \le N _ { l } \}$ , where $x _ { j }$ is the 3D coordinate of the $j$ -th point and $N _ { l }$ is the number of input points to the Set Abstraction module of level $l$ . Each point has a feature of dimension $d _ { l }$ . We concatenate these features with their corresponding 3D coordinates and group them together to form a matrix $\pmb { F } _ { l }$ of shape $N _ { l } \times ( d _ { l } + 3 )$ . The SA module first uses iterative farthest point sampling (FPS) to subsample the input points to $N _ { l + 1 }$ points: $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ . Then it finds $K$ neighbors in the input $\mathbf { \bar { \{ x } }  _ { j } | 1 \leq \mathbf { \bar { \{ j } }  \leq N _ { l } \mathbf  \bar  \{$ for each $y _ { k }$ . We denote the $K$ neighbors of $y _ { k }$ as $\{ x _ { j } | j \in B _ { x } ( y _ { k } ) \}$ , where $B _ { x } ( y _ { k } )$ is the index set of the $K$ neighbors. See definition of neighbors in Appendix A.2. These neighbors and their features are grouped together to form a matrix $G _ { i n }$ of shape $N _ { l + 1 } \times K \times ( d _ { l } + \bar { 3 } )$ . Then a shared multilayer perceptron (MLP) is applied to transform the grouped feature $G _ { i n }$ to $G _ { o u t }$ , which is of shape $N _ { l + 1 } \times K \times d _ { l + 1 }$ and $d _ { l + 1 }$ is the dimension of the output feature. Finally, a max-pooling is applied to aggregate features from the $K$ neighbors $\{ x _ { j } | j \in B _ { x } ( y _ { k } ) \}$ to $y _ { k }$ . We obtain the output of the SA module, the matrix $\mathbf { \Delta } F _ { l + 1 }$ , which is of shape $N _ { l + 1 } \times d _ { l + 1 }$ .
+
+Note that we need to incorporate information of the diffusion step embedding and global feature extracted from the incomplete point cloud $^ c$ to every SA module in the Denoise subnet as shown in Figure 2. We insert these information to the shared MLP that transforms $G _ { i n }$ to $G _ { o u t }$ mentioned in the above paragraph. Specifically, we add them to the channel dimension of the intermediate feature maps in the shared MLP. Figure 3(a) illustrates this process in details. Inspired by the works (Pan et al., 2021; Zhao et al., 2020), we also replace the max-pooling layer in the SA module with a self-attention layer. Feature at $y _ { k }$ is obtained by a weighted sum of the features of its $K$ neighbors $\{ x _ { j } | j \in B _ { x } ( y _ { k } ) \}$ instead of max-pooling, and the weights are adaptively computed through the attention mechanism. See Appendix A.4 for details of this attention layer.
+
+Feature Propagation (FP) Module. Similar to PointNet++, this module upsamples the input point cloud and propagates the input features. In PointNet++, the features are upsampled from $\{ y _ { k } | 1 \le$ $k \leq N _ { l + 1 } \mathrm { \hat { j } }$ to $\{ x _ { j } | 1 \le j \le N _ { l } \}$ by three interpolation: Feature at $x _ { j }$ is a weighted sum of the features of its three nearest neighbors in $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ . We think that the three interpolation operation is not suitable in our task, because the interpolation operation may lose some information about the accurate positions of the points. See a detailed analysis in Appendix Section A.5.
+
+We propose to use a Point Adaptive Deconvolution (PA-Deconv) module to upsample the point features. In the SA module, the features are mapped from set $\{ x _ { j } | 1 \le j \le N _ { l } \}$ to $\bar { \{ y _ { k } \vert 1 \le k \le } $ $N _ { l + 1 } \}$ . The key step is to find the neighbors $\{ x _ { j } | j \in \mathcal { B } _ { x } ( y _ { k } ) \} \subseteq \{ x _ { j } | 1 \leq j \leq N _ { l } \}$ for each $y _ { k }$ . Features at $\{ x _ { j } | \bar { j } \in B _ { x } ( y _ { k } ) \}$ are transformed and then aggregated to the point $y _ { k }$ through either max-pooling or attention mechanism. Now in the FP module, we need to map features the other way around: from $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ to $\{ x _ { j } | 1 \le j \le N _ { l } \}$ . We can achieve this goal through a similar method. We find the neighbors $\{ y _ { k } | \bar { k } \in B _ { y } ( x _ { j } ) \} \subseteq \{ y _ { k } | 1 \leq k \leq N _ { l + 1 } \}$ for each $x _ { j }$ . Features at $\{ y _ { k } | k \in B _ { y } ( x _ { j } ) \}$ are transformed through a shared MLP, and then aggregated to the point $x _ { j }$ through attention mechanism. Similar to SA modules, we insert information of the diffusion step embedding and the global feature extracted from the incomplete point cloud $^ c$ to the shared MLP in every FP module in the Denoise subnet. Finally, same as the original FP module in PointNet++, the upsampled features are concatenated with skip linked point features from the corresponding SA module, and then passed through a unit PointNet. The Feature Propagation module are applied four times and features are eventually propagated to the original input point cloud.
+
+Feature Transfer (FT) Module. The FT module transmits information from the Condition Feature Extraction subnet to the Denoise subnet. Assume the point cloud at level $l$ in the Condition Feature Extraction subnet is $\{ z _ { l } | 1 \le l \le S _ { l } \}$ , where $S _ { l }$ is the number of points at level $l$ in the Condition Feature Extraction subnet. The FT module maps the features at points $\{ z _ { r } | 1 \le r \le S _ { l } \}$ to points at the same level in the Denoise subnet, which are $\{ x _ { j } | 1 \le j \le \mathsf { N } _ { l } \}$ . Then the mapped features are concatenated with the original features at $\{ x _ { j } | 1 \le { \bar { \jmath } } \le N _ { l } \}$ . Next, the concatenated features are fed to the next level of the Denoise subnet. In this way, the Denoise subnet can utilize local features at different levels of the incomplete point cloud to manipulate the noisy input point cloud to form a clean and complete point cloud. The key step in this process is to map features at $\{ z _ { r } | 1 \le r \le S _ { l } \}$ to $\{ x _ { j } | 1 \le { \mathsf { \bar { j } } } \le { \mathsf { \bar { N } } } _ { l } \}$ . We adopt a similar strategy in the SA module. We find the neighbors $\{ z _ { r } | r \in \bar { \mathcal { B } } _ { z } ( x _ { j } ) \} \subseteq \{ z _ { r } | 1 \leq r \leq S _ { l } \}$ for each $x _ { j }$ . Features at $\{ z _ { r } | r \in B _ { z } ( x _ { j } ) \}$ are transformed through a shared MLP, and then aggregated to the point $x _ { j }$ through the attention mechanism, which is a weighted sum of the features at $\bar { \{ z _ { r } | r \in B _ { z } ( \bar { x _ { j } } ) \} }$ .
+
+We set a small distance to define neighbors in low level FT modules, so that they only query the adjacent parts of the incomplete point cloud $^ c$ to preserve local details in it. Large distances are set to define neighbors in high level FT modules. This makes high-level FT modules have large receptive fields, so that they can query a large part of the incomplete point cloud to infer high level 3D structural relations. See detailed neighbor definitions in Appendix Section A.2.
+
+# 3.3 REFINEMENT NETWORK
+
+We denote the coarse point cloud generated by the Conditional Generation Network as $U$ . We use another network of the same architecture shown in Figure 2 to predict a per-point displacement for $U$ to refine it. The differences are that the input to the Denoise subnet becomes $U$ and we do not need to insert the diffusion step embedding to the Denoise subnet. The predicted displacement are added to $U$ to obtain the refined point cloud $V \colon v = u + \gamma \epsilon _ { f } ( u , c )$ , where $v , u , c$ are the concatenated 3D coordinates of the point clouds $V , U , C$ , respectively. $\gamma$ is a small constant and we set it to 0.001 in all our experiments. $\epsilon _ { f }$ is the ReFinement Network. We use the Chamfer Distance (CD) loss between the refined point cloud $V$ and ground truth point cloud $\boldsymbol { X }$ to supervise the network $\epsilon _ { f }$ :
+
+$$
+\mathcal { L } _ { \mathrm { C D } } ( { \boldsymbol { V } } , { \boldsymbol { X } } ) = \frac { 1 } { | V | } \sum _ { v \in V } \operatorname* { m i n } _ { x \in { \boldsymbol { X } } } | | v - x | | ^ { 2 } + \frac { 1 } { | \boldsymbol { X } | } \sum _ { x \in { \boldsymbol { X } } } \operatorname* { m i n } _ { v \in V } | | v - x | | ^ { 2 } ,
+$$
+
+where $| V |$ means number of points in $V$ . If we also want to upsample points in $U$ by a factor of $\lambda$ , we can simply increase the output dimension of the network $\epsilon _ { f }$ . In addition to predicting one 3D displacement of each point in $U$ , we predict another $\lambda$ displacements. We consider each point in the refined point cloud $V$ as the center of a group of $\lambda$ points in the dense point cloud that we want to generate. The additional $\lambda$ displacements are added to every point in $V$ to form a dense point cloud. Figure 3(c) illustrates how we upsample every point in $V$ by a factor of $\lambda = 8$ .
+
+When training the ReFinement Network $\epsilon _ { f }$ , parameters in the Conditional Generation Network $\epsilon _ { \theta }$ are fixed. It is not practical to generate coarse point clouds $U$ on the fly in the training process of $\epsilon _ { f }$ , because the generation process of DDPM is slow. Instead, we generate and save the coarse point clouds in advance. Due to the probabilistic nature of DDPM, we generate 10 coarse point clouds for each incomplete point cloud in the dataset to increase diversity of training data.
+
+# 4 RELATED WORKS
+
+Point cloud completion. Inspired by the pioneering work, PointNet (Qi et al., 2017a), researchers focus on learning global feature embeddings from 3D point clouds for completion (Yuan et al., 2018; Tchapmi et al., 2019), which however cannot predict local and thin shape structures. To address these challenges, following research works (Pan, 2020; Xie et al., 2020; Zhang et al., 2020; Wen et al., 2021; Yu et al., 2021; Pan et al., 2021) exploit multi-scale local point features to reconstruct complete point clouds with fine-grained geometric details. Recently, PointTr (Yu et al., 2021) and VRCNet (Pan et al., 2021) provide impressive point cloud completion results with the help of attention-based operations. Nonetheless, as a challenging conditional generation problem, point cloud completion has not been fully resolved.
+
+DDPM for point cloud generation. Luo & Hu (2021) are the first to use DDPM for unconditional point cloud generation. They use a Pointwise-net to generate point clouds, which is similar to a 2-stage PointNet used for point cloud part segmentation. However, the Pointwise-net could only receive a global feature. It can not leverage fine-grained local structures in the incomplete point cloud. Zhou et al. (2021) further use conditional DDPM for point cloud completion by training a point-voxel CNN (Liu et al., 2019), but the way they use the incomplete point cloud $^ c$ is different from ours. They directly concatenate $^ c$ with the noisy input $\mathbf { \boldsymbol { x } } ^ { t }$ , and feed them to a single pointvoxel CNN. This may hurt performance of the network, because the concatenated point cloud is very likely to be non-uniform. In addition, $\mathbf { \boldsymbol { x } } ^ { t }$ is very different from $^ c$ for large $t$ ’s due to the large noise magnitude in $\mathbf { \boldsymbol { x } } ^ { t }$ . Feeding two point clouds of very different properties to a single network at once could be quite confusing for the network. The other major difference is that they do not refine or upsample the coarse point cloud generated by DDPM like we do.
+
+# 5 EXPERIMENTS
+
+# 5.1 DATASETS
+
+We conduct point cloud completion experiments on the following three datasets. MVP. The MVP dataset (Pan et al., 2021) has 62400 training partial-complete point cloud pairs and 41600 testing pairs sampled from ShapeNet (Chang et al., 2015). Every partial point cloud has 2048 points. In particular, MVP dataset provides ground truth point clouds with different resolutions, including 2048, 4096, 8192, and 16384 points. MVP-40. The MVP-40 dataset (Pan et al., 2021) consists of 41600 training samples and 64168 testing samples from 40 categories in ModelNet40 (Wu et al., 2015). Its partial point clouds are sampled from complete point clouds with a pre-defined missing ratio, i.e., $50 \%$ , $2 5 \%$ and $1 2 . 5 \%$ missing. Both the partial and complete point clouds have 2048 points. Completion3D. It (Tchapmi et al., 2019) consists of 28974 point cloud pairs for training and 1184 for testing from 8 object categories in ShapeNet. Both the partial and complete point clouds have 2048 points. We find some pairs of the incomplete point cloud and complete point cloud have inconsistent scales in the Completion3D dataset. We correct the scales and use the corrected dataset in our experiments. See details in Appendix Section B.4.
+
+# 5.2 EVALUATION METRICS
+
+We use the Chamfer Distance (CD), Earth Mover Distance (EMD), and F1 score to evaluate the quality of the generated point clouds. CD distance is defined in Equation 5.
+
+Earth Mover Distance. Consider the predicted point cloud $V$ and the ground truth point cloud $\boldsymbol { X }$ of equal size $N = | V | = | X |$ , the EMD loss penalizes their shape discrepancy by optimizing a transportation problem. It estimates a bijection $\phi : V \longleftrightarrow X$ between $V$ and $\boldsymbol { X }$ :
+
+$$
+\mathcal { L } _ { \mathrm { E M D } } ( V , X ) = \operatorname* { m i n } _ { \phi : V : \longrightarrow X } \sum _ { v \in V } \big \| v - \phi ( v ) \big \| _ { 2 } .
+$$
+
+F1 score. To compensate the problem that CD loss can be sensitive to outliers, we follow previous methods (Pan et al., 2021; Tatarchenko et al., 2019) and use F1 score to explicitly evaluates the distance between object surfaces, which is defined as the harmonic mean between precision ${ \mathcal { L } } _ { \mathrm { P } } ( \rho )$ and recall $\mathcal { L } _ { \mathrm { R } } ( { \boldsymbol \rho } )$ : $\begin{array} { r } { \mathcal { L } _ { \mathrm { F 1 } } = \frac { 2 \mathcal { L } _ { \mathrm { P } } ( \rho ) \mathcal { L } _ { \mathrm { R } } ( \rho ) } { \mathcal { L } _ { \mathrm { P } } ( \rho ) + \mathcal { L } _ { \mathrm { R } } ( \rho ) } } \end{array}$ , where $\mathcal { L } _ { \mathrm { P } } ( \boldsymbol { \rho } ) = \frac { 1 } { | \boldsymbol { V } | } \sum _ { \boldsymbol { v } \in \boldsymbol { V } } \left[ \operatorname* { m i n } _ { \boldsymbol { x } \in \boldsymbol { X } } \big | \big | \boldsymbol { x } - \boldsymbol { v } \big | \big | ^ { 2 } < \boldsymbol { \rho } \right] , \mathcal { L } _ { \mathrm { R } } ( \boldsymbol { \rho } ) =$ $\frac { 1 } { | X | } \sum _ { x \in X } \left[ \operatorname* { m i n } _ { v \in V } \left\| x - v \right\| ^ { 2 } < \rho \right] .$ , and $\rho$ is a predefined distance threshold. We set $\rho = 1 0 ^ { - 4 }$ for the MVP and Completion3D datasets, and set $\rho = 1 0 ^ { - 3 }$ for the MVP-40 dataset.
+
+Table 1: Point cloud completion results on MVP, MVP-40 and Completion3D datasets at the resolution of 2048 points. CD loss is multiplied by $1 0 ^ { 4 }$ . EMD loss is multiplied by $\mathrm { \dot { 1 } 0 ^ { 2 } }$ . Scale factors of the two losses are the same in all the other tables. The two losses are the lower the better, while F1 score is the higher the better. Note that MVP-40 dataset has larger CD and EMD losses because objects in it have larger scales than the other two datasets. Results of MVP-40 dataset at $2 5 \%$ missing ratio is complemented in Appendix Table 5.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">MVP</td><td colspan="3">MVP40 (50% missing)</td><td colspan="3">MVP40 (12.5% missing)</td><td colspan="3">Completion3D</td></tr><tr><td>CD</td><td>EMD</td><td>F1</td><td>CD</td><td>EMD</td><td>F1</td><td>CD</td><td>EMD</td><td>F1</td><td>CD</td><td>EMD</td><td>F1</td></tr><tr><td>PCN (Yuan et al., 2018)</td><td>8.65</td><td>1.95</td><td>0.342</td><td>39.67</td><td>6.37</td><td>0.581</td><td>32.56</td><td>6.18</td><td>0.619</td><td>8.81</td><td>3.03</td><td>0.315</td></tr><tr><td>TopNet (Tchapmi et al., 2019)</td><td>10.19</td><td>2.44</td><td>0.299</td><td>48.52</td><td>8.75</td><td>0.506</td><td>40.12</td><td>9.08</td><td>0.542</td><td>11.56</td><td>3.69</td><td>0.257</td></tr><tr><td>FoldingNet (Yang et al., 2018)</td><td>10.54</td><td>3.64</td><td>0.256</td><td>51.89</td><td>11.66</td><td>0.441</td><td>46.03</td><td>8.93</td><td>0.480</td><td>14.32</td><td>4.81</td><td>0.186</td></tr><tr><td>MSN (Liu et al., 2020)</td><td>7.08</td><td>1.71</td><td>0.434</td><td>34.33</td><td>9.70</td><td>0.646</td><td>20.20</td><td>4.54</td><td>0.728</td><td>8.88</td><td>2.69</td><td>0.359</td></tr><tr><td>Cascade (Wang et al., 2020)</td><td>6.83</td><td>2.14</td><td>0.436</td><td>34.16</td><td>15.40</td><td>0.635</td><td>26.73</td><td>5.71</td><td>0.657</td><td>7.31</td><td>2.70</td><td>0.408</td></tr><tr><td>ECG (Pan, 2020)</td><td>7.06</td><td>2.36</td><td>0.443</td><td>34.06</td><td>16.19</td><td>0.671</td><td>40.00</td><td>6.98</td><td>0.597</td><td>10.43</td><td>3.63</td><td>0.300</td></tr><tr><td>GRNet (Xie et al., 2020)</td><td>7.61</td><td>2.36</td><td>0.353</td><td>35.99</td><td>12.33</td><td>0.589</td><td>22.04</td><td>6.43</td><td>0.646</td><td>8.54</td><td>2.87</td><td>0.314</td></tr><tr><td>PMPNet (Wen et al.,2021)</td><td>5.85</td><td>3.42</td><td>0.475</td><td>25.41</td><td>29.92</td><td>0.721</td><td>13.00</td><td>8.92</td><td>0.815</td><td>7.45</td><td>4.85</td><td>0.386</td></tr><tr><td>VRCNet (Pan et al.,2021)</td><td>5.82</td><td>2.31</td><td>0.495</td><td>25.70</td><td>18.40</td><td>0.736</td><td>14.20</td><td>5.90</td><td>0.807</td><td>6.69</td><td>3.57</td><td>0.433</td></tr><tr><td>PDR paradigm (Ours)</td><td>5.66</td><td>1.37</td><td>0.499</td><td>27.20</td><td>2.68</td><td>0.739</td><td>12.70</td><td>1.39</td><td>0.827</td><td>7.10</td><td>1.75</td><td>0.451</td></tr></table>
+
+Table 2: Completion results on MVP dataset at the resolution of 4096, 8192, 16384 points.   
+
+<table><tr><td rowspan=2 colspan=1>#Points</td><td rowspan=1 colspan=1>4096</td><td rowspan=1 colspan=1>8192</td><td rowspan=1 colspan=1>16384</td></tr><tr><td rowspan=1 colspan=1>CD  F1</td><td rowspan=1 colspan=1>CD  F1</td><td rowspan=1 colspan=1>CD  F1</td></tr><tr><td rowspan=1 colspan=1>PCNTopNet</td><td rowspan=1 colspan=1>7.140.4697.690.434</td><td rowspan=1 colspan=1>6.020.5776.640.526</td><td rowspan=1 colspan=1>5.180.6505.140.618</td></tr><tr><td rowspan=1 colspan=1>FoldingNet</td><td rowspan=1 colspan=1>8.760.351</td><td rowspan=1 colspan=1>6.900.433</td><td rowspan=1 colspan=1>6.980.464</td></tr><tr><td rowspan=1 colspan=1>MSN</td><td rowspan=1 colspan=1>5.370.583</td><td rowspan=1 colspan=1>4.400.663</td><td rowspan=1 colspan=1>4.090.696</td></tr><tr><td rowspan=1 colspan=1>Cascade</td><td rowspan=1 colspan=1>5.460.579</td><td rowspan=1 colspan=1>4.510.686</td><td rowspan=1 colspan=1>3.900.743</td></tr><tr><td rowspan=1 colspan=1>ECG</td><td rowspan=1 colspan=1>7.310.506</td><td rowspan=1 colspan=1>3.990.717</td><td rowspan=1 colspan=1>3.320.774</td></tr><tr><td rowspan=1 colspan=1>GRNet</td><td rowspan=1 colspan=1>5.730.493</td><td rowspan=1 colspan=1>4.510.616</td><td rowspan=1 colspan=1>3.540.700</td></tr><tr><td rowspan=1 colspan=1>PoinTrVRCNet</td><td rowspan=1 colspan=1>4.290.6384.620.629</td><td rowspan=1 colspan=1>3.520.7253.390.734</td><td rowspan=1 colspan=1>2.950.7832.810.780</td></tr><tr><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>4.260.649</td><td rowspan=1 colspan=1>3.350.754</td><td rowspan=1 colspan=1>2.610.817</td></tr></table>
+
+Table 3: Comparison of different network structures in term of training the conditional generation network and refinement network.   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>CD  EMD  F1</td></tr><tr><td rowspan=2 colspan=1>GenerateCoarsePoints</td><td rowspan=2 colspan=1>Pointwise-netConcatext &amp; cPointNet++PA-DeonvPA-Deonv &amp; Att.</td><td rowspan=1 colspan=1>11.99 1.630.265</td></tr><tr><td rowspan=1 colspan=1>10.791.540.3829.39 1.380.3558.81 1.340.3798.71 1.290.389</td></tr><tr><td rowspan=5 colspan=1>RefineCoarsePoints</td><td rowspan=3 colspan=1>Pointwise-netConcatext &amp;cPointNet++</td><td rowspan=1 colspan=1>7.71 1.450.407</td></tr><tr><td rowspan=1 colspan=1>5.78 1.380.490</td></tr><tr><td rowspan=1 colspan=1>6.03 1.400.480</td></tr><tr><td rowspan=2 colspan=1>PA-DeonvPA-Deonv &amp; Att.</td><td rowspan=1 colspan=1>5.96 1.400.482</td></tr><tr><td rowspan=1 colspan=1>5.66 1.370.499</td></tr></table>
+
+# 5.3 POINT CLOUD COMPLETION
+
+We compare our point cloud completion method with previous state-of-the-art point cloud completion methods. The comparison is performed on MVP, MVP-40, and Completion3D datasets. Results are shown in Table 1. We also conduct multi-resolution experiments on the MVP dataset, and results are shown in Table 2. Detailed experimental setups are provided in Appendix Section B.1. We can see that our Conditional Point Diffusion-Refinement (PDR) paradigm outperforms other methods by a large margin in terms of EMD loss, which is highly indicative of uniformness (Zhang et al., 2021). We also achieve the highest F1 score and very low CD loss. Although VRCNet sometimes has lower CD loss than ours, it tends to put more points in the parts that are known in the incomplete point clouds, while put less points in the missing part (See Figure 10 in Appendix). In this way, its CD loss could be very low, but this non-uniformness is undesired and leads to very high EMD loss. We compare our method with other baselines in terms of visual quality of completed point clouds in Figure 4. We can see that our method generally has better visual quality. More samples are provided in Figure 9 and Figure 11 in Appendix. We also find that our PDR paradigm demonstrate some diversity in completion results as discussed in Appendix B.8.
+
+Ablation Study. We study the effect of attention mechanism, Point Adaptive Deconvolution (PADeconv) module, and Feature Transfer (FT) module in term of training the Conditional Generation Network and the Refinement Network. The experiments are conducted on MVP dataset at the resolution of 2048 points and results are shown in Table 3. “PA-Deonv & Att.” is our proposed complete network shown in Figure 2. “PA-Deonv” removes attention mechanism. “PointNet $+ + ^ { \prime }$ further removes PA-Deconv module. “Concate $\mathbf { \boldsymbol { x } } ^ { t }$ & $c ^ { \prime \prime }$ removes FT modules. It concatenates $^ c$ with $\mathbf { \boldsymbol { x } } ^ { t }$ as Zhou et al. (2021) do, and feed them to a single PointNe $^ { + + }$ with attention mechanism and PADeconv. “Pointwise-net” only utilizes a global feature extracted from the incomplete point cloud. We can see that these proposed modules indeed improve the networks’ performance. Note that the conditional generation networks in Table 3 are trained without data augmentation. Complete experimental results with data augmentation are presented in Appendix Section B.6. All the refinement networks are trained using data generated by our proposed complete dual-path network trained with data augmentation. If the other ablated networks use training data generated by themselves, they would have worse refinement results.
+
+![](images/782116d643a7bf605695d0838f2d6f75df2c4680a8c888b2324704751bc50922.jpg)  
+Figure 4: Visual comparison of point cloud completion results on the MVP dataset (16384 points).
+
+![](images/303533c82aa8d54bd8c2802cc75b1f0af52057feed898df468ae0f2941386748.jpg)  
+Figure 5: Our method can be extended to controllable point cloud generation.
+
+DDPM acceleration. Kong & Ping (2021) propose to accelerate the generation process of DDPM by jumping steps in the reverse process. The method does not need retraining of the DDPM. We directly apply their method to our 3D point cloud generation network. However, we observe a considerable performance drop in the accelerated DDPM. On the MVP dataset (2048 points), the original 1000-step DDPM achieves $1 0 . 7 \times 1 0 ^ { - 4 }$ CD loss. CD losses of the accelerated 50-step and 20-step DDPMs increase to $1 3 . 2 \times 1 0 ^ { - 4 }$ and $1 8 . 1 \times 1 0 ^ { - 4 }$ , respectively. Fortunately, we can generate coarse point clouds using the accelerated DDPMs and use another Refinement Network to refine them. The refined point clouds of the 50-step and 20-step DDPMs bear CD losses of $5 . 6 8 \times 1 0 ^ { - 4 }$ and $5 . 7 8 \times 1 0 ^ { - 4 }$ , respectively. Compared with the original 1000-step DDPM, which has a CD loss of $5 . 6 6 \times 1 0 ^ { - 4 }$ , it’s quite temping to accept a slight drop in performance for an acceleration up to 50 times. Complete results of the acceleration experiment are presented in Appendix Section B.7.
+
+# 5.4 EXTENSION TO CONTROLLABLE GENERATION
+
+Our conditional PDR paradigm can be readily extended to controllable point cloud generation conditioned on bounding boxes of every part of an object. We sample points on the surfaces of the bounding boxes and regard this point cloud as the conditioner, just like the incomplete point cloud serves as the conditioner for point cloud completion. We conduct experiments on the chair category of PartNet (Mo et al., 2019) dataset. Two examples are shown in Figure 5. It’s interesting that our method can generate a shape different from the ground truth in some details, but be still plausible.
+
+# 6 CONCLUSION
+
+In this paper, we propose the Conditional Point Diffusion-Refinement (PDR) paradigm for point cloud completion. Our method effectively leverages the strong spatial correspondence between the adjacent parts of the incomplete point cloud and the complete point cloud through the proposed Feature Transfer module, which could also infer high-level 3D structural relations. We make improvements of the backbone PointNe $^ { + + }$ to make it capable of accurately manipulating positions of input points. Our method demonstrate significant advantages over previous methods, especially in terms of the overall distribution of the generated point cloud. We also find that our method has great potential to be applied in other conditional point cloud generation tasks such as controllable point cloud generation.
+
+# 7 ACKNOWLEDGEMENTS
+
+This work is partially supported by General Research Fund (GRF) of Hong Kong (No. 14205719).   
+The authors thank useful discussions with Quan Wang from SenseTime and Tong Wu from CUHK.
+
+# REFERENCES
+
+Angel X. Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. ShapeNet: An Information-Rich 3D Model Repository. Technical Report arXiv:1512.03012 [cs.GR], Stanford University — Princeton University — Toyota Technological Institute at Chicago, 2015.
+
+Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. arXiv preprint arXiv:2006.11239, 2020.
+
+Zhifeng Kong and Wei Ping. On fast sampling of diffusion probabilistic models. arXiv preprint arXiv:2106.00132, 2021.
+
+Zhifeng Kong, Wei Ping, Jiaji Huang, Kexin Zhao, and Bryan Catanzaro. DiffWave: A versatile diffusion model for audio synthesis. arXiv preprint arXiv:2009.09761, 2020.
+
+Minghua Liu, Lu Sheng, Sheng Yang, Jing Shao, and Shi-Min Hu. Morphing and sampling network for dense point cloud completion. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pp. 11596–11603, 2020.
+
+Zhijian Liu, Haotian Tang, Yujun Lin, and Song Han. Point-voxel cnn for efficient 3d deep learning. arXiv preprint arXiv:1907.03739, 2019.
+
+Shitong Luo and Wei Hu. Diffusion probabilistic models for 3d point cloud generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2837–2845, 2021.
+
+Kaichun Mo, Shilin Zhu, Angel X Chang, Li Yi, Subarna Tripathi, Leonidas J Guibas, and Hao Su. Partnet: A large-scale benchmark for fine-grained and hierarchical part-level 3d object understanding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 909–918, 2019.
+
+Alex Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. arXiv preprint arXiv:2102.09672, 2021.
+
+Liang Pan. Ecg: Edge-aware point cloud completion with graph convolution. IEEE Robotics and Automation Letters, 2020.
+
+Liang Pan, Xinyi Chen, Zhongang Cai, Junzhe Zhang, Haiyu Zhao, Shuai Yi, and Ziwei Liu. Variational relational point completion network. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8524–8533, 2021.
+
+Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 652–660, 2017a.
+
+Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017b. URL https://proceedings.neurips.cc/paper/2017/file/ d8bf84be3800d12f74d8b05e9b89836f-Paper.pdf.
+
+Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv preprint arXiv:1710.05941, 7:1, 2017.
+
+Jascha Sohl-Dickstein, Eric A Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. arXiv preprint arXiv:1503.03585, 2015.
+
+Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. arXiv preprint arXiv:2010.02502, 2020.
+
+Maxim Tatarchenko, Stephan R Richter, Rene Ranftl, Zhuwen Li, Vladlen Koltun, and Thomas ´ Brox. What do single-view 3d reconstruction networks learn? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3405–3414, 2019.
+
+Lyne P Tchapmi, Vineet Kosaraju, Hamid Rezatofighi, Ian Reid, and Silvio Savarese. Topnet: Structural point cloud decoder. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 383–392, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+Xiaogang Wang, Marcelo H Ang Jr, and Gim Hee Lee. Cascaded refinement network for point cloud completion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 790–799, 2020.
+
+Xin Wen, Peng Xiang, Zhizhong Han, Yan-Pei Cao, Pengfei Wan, Wen Zheng, and Yu-Shen Liu. Pmp-net: Point cloud completion by learning multi-step point moving paths. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7443–7452, 2021.
+
+Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1912–1920, 2015.
+
+Yaqi Xia, Yan Xia, Wei Li, Rui Song, Kailang Cao, and Uwe Stilla. Asfm-net: Asymmetrical siamese feature matching network for point completion, 2021.
+
+Haozhe Xie, Hongxun Yao, Shangchen Zhou, Jiageng Mao, Shengping Zhang, and Wenxiu Sun. Grnet: Gridding residual network for dense point cloud completion. arXiv preprint arXiv:2006.03761, 2020.
+
+Yaoqing Yang, Chen Feng, Yiru Shen, and Dong Tian. Foldingnet: Point cloud auto-encoder via deep grid deformation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 206–215, 2018.
+
+Xumin Yu, Yongming Rao, Ziyi Wang, Zuyan Liu, Jiwen Lu, and Jie Zhou. Pointr: Diverse point cloud completion with geometry-aware transformers. arXiv preprint arXiv:2108.08839, 2021.
+
+Wentao Yuan, Tejas Khot, David Held, Christoph Mertz, and Martial Hebert. Pcn: Point completion network. In 2018 International Conference on 3D Vision (3DV), pp. 728–737. IEEE, 2018.
+
+Junzhe Zhang, Xinyi Chen, Zhongang Cai, Liang Pan, Haiyu Zhao, Shuai Yi, Chai Kiat Yeo, Bo Dai, and Chen Change Loy. Unsupervised 3d shape completion through gan inversion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1768–1777, 2021.
+
+Wenxiao Zhang, Qingan Yan, and Chunxia Xiao. Detail preserved point cloud completion via separated feature aggregation. arXiv preprint arXiv:2007.02374, 2020.
+
+Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip Torr, and Vladlen Koltun. Point transformer. arXiv preprint arXiv:2012.09164, 2020.
+
+Linqi Zhou, Yilun Du, and Jiajun Wu. 3d shape generation and completion through point-voxel diffusion. arXiv preprint arXiv:2104.03670, 2021.
+
+# APPENDIX
+
+# A METHODOLOGY DETAILS
+
+# A.1 DETAILS OF THE DDPM
+
+Hyperparameters $\beta _ { t }$ . We define hyperparameters $\beta _ { t }$ in the diffusion process according to a linear schedule. We let $\beta _ { 1 } = 1 \times 1 0 ^ { - 4 }$ and $\bf { \dot { \beta } } _ { T } = 2 \times 1 0 ^ { - 2 }$ . Then, we define $\begin{array} { r } { \beta _ { t } = \frac { t - 1 } { T - 1 } \cdot ( \beta _ { T } - \beta _ { 1 } ) , t = } \end{array}$ $1 , 2 , \cdots , T$ .
+
+Diffusion step embedding. The network $\epsilon$ needs to output different $\epsilon _ { \theta } ( \pmb { x } ^ { t } , \pmb { c } , t )$ for different diffusion steps $t \in \{ 1 , \cdots , T \}$ . We first use positional encoding (Vaswani et al., 2017) to encode each $t$ into a $2 d _ { t }$ dimensional vector $\phi _ { \mathrm { e m b } } ( t ) = [ \sin ( \psi ( t ) ) , \cos ( \psi ( t ) ) ]$ , where
+
+$$
+\psi ( t ) = \left[ 1 0 ^ { \frac { 4 \times 0 } { d _ { t } } t } , 1 0 ^ { \frac { 4 \times 1 } { d _ { t } } t } , \cdot \cdot \cdot , 1 0 ^ { \frac { 4 \times ( d _ { t } - 1 ) } { d _ { t } } t } \right] .
+$$
+
+We set $d _ { t } = 6 4$ in experiments. Then, we use two fully-connected (FC) layers to transform $\phi _ { \mathrm { e m b } } ( t )$ into a 512 dimensional embedding vector (Ho et al., 2020). The first FC layer has input dimension $2 d _ { t } = 1 2 8$ and output dimension 512. The second FC layer has input dimension 512 and output dimension 512. Both layers are followed by the Swish activation function (Ramachandran et al., 2017).
+
+# A.2 NEIGHBOR DEFINITION
+
+In the Set Abstraction module and the Feature Transfer module, the neighbors are defined as the points that are within a specified distance to the center point. If a center point has more than $K$ neighbors, we randomly select $K$ neighbors from its neighbors. If a center point has less than $K$ neighbors, we pad it with dummy neighbors that has the same position as the center point, and has features of zeros. These dummy neighbors are excluded from the max-pooling operation. And in the attention mechanism, the weights of the dummy neighbors are manually set to 0. In this way, we can guarantee that a center point can always find $K$ neighbors. We set $K = 3 2$ in the Set Abstraction module and the Feature Transfer module. In the 4 levels of the Set Abstraction modules, the neighboring distance are set to 0.1, 0.2, 0.4, 0.8, respectively. In the 9 Feature Transfer modules, the neighboring distance are set to $0 . 1 , 0 . 2 , 0 . 4 , 0 . 8 , 1 , 6 , 0 . 8 , 0 . 4 , 0 . 2 , 0 . 1$ , respectively. Coordinates of samples in all datasets are normalized to the range $[ - 1 , 1 ]$ .
+
+In the Point Adaptive Deconvolution (PA-Deconv) modules of the Feature Propagation modules, the $K$ neighbors are defined as the $K$ nearest neighbors of the center point, and we set $K = 8$ for all Feature Propagation modules.
+
+# A.3 PROBLEMS OF VANILLA POINTNET $^ { + + }$
+
+Zhou et al. (2021) argue that PointNet $^ { + + }$ can not be used to train a DDPM. We observe the same phenomenon in our experiments. We find that this is because the density of the input noisy cloud $\bar { \boldsymbol { x } } ^ { t }$ is too low for large $t$ ’s. Recall that $\pmb { x } ^ { t } = \sqrt { \bar { \alpha } _ { t } } \pmb { x } ^ { 0 } + \sqrt { 1 - \bar { \alpha } _ { t } } \epsilon$ , where $\epsilon$ is a Gaussian noise. $\bar { \alpha } _ { t }$ goes to 0 for large $t$ ’s. This means $\mathbf { \boldsymbol { x } } ^ { t }$ is close to a Gaussian noise when $t$ is large. The density of a Gaussian noise is much lower than the complete point cloud $\pmb { x } ^ { 0 }$ . This is because points in $\mathbf { x } ^ { \mathrm { { 0 } } }$ concentrate on the surface of some object and $\mathbf { x } ^ { 0 }$ is normalized to the range $[ - 1 , 1 ]$ , while points from a standard Gaussian distribution could fill the whole space in the range of $[ - 3 , 3 ]$ .
+
+PointNet++ is originally designed to process point clouds like $\mathbf { \boldsymbol { x } } ^ { 0 }$ . It’s selection of distances to define neighbors described in Appendix Section A.2 is suitable for point clouds that have the same level of density as $\mathbf { \boldsymbol { x } } ^ { 0 }$ , but can not handle point clouds close to a Gaussian noise. Indeed, we find the average number of neighbors for each point in the four levels of the Set Abstraction modules are 22.3984, 29.9133, 29.3266, 27.8375, respectively, for 10 random shapes sampled from the MVP dataset. In constrast, the average number of neighbors for each point in the four levels are $1 . 0 8 6 4 , 1 , 1 , 1$ for 10 random point clouds sampled from the Gaussian distribution. Note that each point itself is considered to be a neighbor of itself. This means most points do not have any neighbors besides itself in a Gaussian noise.
+
+PointNet $^ { + + }$ only utilizes the relative positions of input points. The input feature of each point to the first Set Abstraction module is its relative position to the center point, which is subsampled from the original input points by farthest point sampling. No information can be extracted when points do not have neighbors. This is the reason why PointNet $^ { + + }$ can not be directly used to train a DDPM.
+
+Our solution is to attach the absolute position of each point to its feature. This guarantees that a point at least can utilize its own position to decide which direction to move when it does not have neighbors. Afterall, a point cloud with large magnitude noises does not have many meaningful structures. There is not much information in the relative positions of points. Another solution is to change the definition of neighbors: From points within a specified distance to K-nearest neighbors. This guarantees that a point always has $K$ neighbors. We conduct experiments to compare these two solutions, and we find that their performances are basically the same. Therefore, we just stick to the original neighbor definitions in PointNet++.
+
+# A.4 ATTENTION MECHANISM
+
+In Section 3.2 in the main text, we mentioned that we use the attention mechanism instead of maxpooling to aggregate features at the neighboring points to the center point. We take the Set Abstraction module as an example to elaborate on the attention mechanism. Attention mechanism in the Feature Propagation module and Feature Transfer module is similarly designed.
+
+Assume we want to propagate features from $\{ x _ { j } | 1 \le j \le N _ { l } \}$ to $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ . Each point in $\{ x _ { j } | 1 \le j \le N _ { l } \}$ has a feature of dimension $d _ { l }$ . We concatenate these features with their corresponding 3D coordinates and group them together to form a matrix $\pmb { F } _ { l }$ of shape $N _ { l } \times ( d _ { l } + 3 )$ . We finds $K$ neighbors in the input set $\bar { \{ x _ { j } \vert 1 \leq \bar { j } } \leq N _ { l } \}$ for each $y _ { k }$ . These neighbors together with their features are grouped together to form a matrix $G _ { i n }$ of shape $N _ { l + 1 } \times K \times ( d _ { l } + 3 )$ . Then a shared multi-layer perceptron (MLP) is applied to transform the grouped feature $G _ { i n }$ to $G _ { o u t }$ , which is a matrix of shape $N _ { l + 1 } \times K \times d _ { l + 1 }$ and $d _ { l + 1 }$ is the dimension of the output feature.
+
+In our attention mechanism, $G _ { i n }$ (shape $N _ { l + 1 } \times K \times ( d _ { l } + 3 ) )$ will act like keys, $G _ { o u t }$ (shape $N _ { l + 1 } \times K \times d _ { l + 1 } )$ will act like values, while the original features at $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ will act like queries. Since $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ is a subset of $\{ x _ { j } | 1 \le j \le N _ { l } \}$ , we can group the original features at $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ to form a matrix $Q$ , which is of shape $N _ { l + 1 } \times ( d _ { l } + 3 ) . 6$ $Q$ is first repeated $K$ times into a matrix of shape $N _ { l + 1 } \times K \times ( d _ { l } + 3 )$ . Then this matrix is passed through a shared MLP and transformed into a matrix $\pmb { Q } ^ { \prime }$ , which is of shape $N _ { l + 1 } \times K \times d _ { q u e r y }$ . Next, we pass $G _ { i n }$ through a shared MLP to transform it into a new matrix ${ \bf { { G } } } _ { i n } ^ { \prime }$ , which is of shape $N _ { l + 1 } \times K \times d _ { k e y }$ . We concatenate the query matrix $\pmb { Q } ^ { \prime }$ with the key matrix ${ \bf { { G } } } _ { i n } ^ { \prime }$ along the feature dimension. We denote this matrix as $[ \bar { Q ^ { \prime } } , \bar { G } _ { i n } ^ { \prime } ]$ , which is of shape $N _ { l + 1 } \times K \stackrel { \cdots } { \times } ( d _ { q u e r y } + d _ { k e y } )$ . $[ Q ^ { \prime } , G _ { i n } ^ { \prime } ]$ is passed through a shared MLP to obtain the scores of all the $K$ neighbors. We denote the scores as matrix $_ { s }$ of shape $N _ { l + 1 } \times K \times d _ { l + 1 }$ . Note that $_ { s }$ has the same shape as $G _ { o u t }$ . And the scores $\pmb { S }$ of the $K$ neighbors are adaptively computed according to the feature at the center point $y _ { k }$ and features at its $K$ neighbors $\{ x _ { j } | j \in B _ { x } ( y _ { k } ) \}$ . We apply a softmax operation along the neighbor dimension (the second dimension) of $_ { s }$ to obtain the weight matrix of all the $K$ neighbors. We denote it as $W$ , which is of shape $N _ { l + 1 } \times K \times d _ { l + 1 }$ . Note that we manually set the weights of the padded dummy neighbors to 0 in $W$ . Then the weight matrix $W$ and the value matrix $G _ { o u t }$ are dot producted along the neighbor dimension (the second dimension) to form the output matrix ${ \pmb F } ^ { \prime }$ , which is of shape $N _ { l + 1 } \times d _ { l + 1 }$ . Finally, $\pmb { F } ^ { \prime }$ is concatenated with the 3D coordinates of the set $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ to form output of the Set Abstraction module, $\mathbf { \Delta } F _ { l + 1 }$ , which is a matrix of shape $N _ { l + 1 } \times ( d _ { l + 1 } + 3 ) .$
+
+# A.5 PROBLEMS WITH THREE INTERPOLATION
+
+The original PointNet $^ { + + }$ uses three interpolation to upsample features in the Feature Propagation module. We think that the three interpolation operation is suitable for tasks like point cloud part segmentation, but not suitable in our task. Interpolation means that points close to each other have similar features. Points close to each other tend to have similar semantic labels in a clean point cloud, therefore it is meaningful to use interpolation operation to upsample features in the part segmentation task. However, in our task, the network need to predict a per-point displacement for all points in a noisy point cloud and move it towards a clean point cloud. Points close to each other do not need to move in a similar direction in general. In fact, they may just need to move towards the opposite direction to form a smooth surface.
+
+We also find that the three interpolation operation lacks the ability to manipulate positions of points accurately in small scales. We first elaborate on the three interpolation operation used in the original PointNet $^ { + + }$ . Assume we want to upsample features at $\{ y _ { k } | 1 \stackrel { \cdot } { \leq } k \leq \dot { N } _ { l + 1 } \}$ to $\{ x _ { j } | 1 \le j \le \mathsf { \bar { N } } _ { l } \}$ , where $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ is a subset of $\{ x _ { j } | 1 \le j \le \dot { N _ { l } } \}$ .
+
+For each $x _ { j }$ , assume its three nearest neighbors in $\{ y _ { k } | 1 \le k \le N _ { l + 1 } \}$ are $\{ y _ { k } | k \in B _ { y , 3 } ( x _ { j } ) \}$ . Then feature at $x _ { j }$ is obtained through the following equation:
+
+$$
+f ( x _ { j } ) = \frac { \sum _ { k \in \mathcal { B } _ { y , 3 } ( x _ { j } ) } w ( y _ { k } , x _ { j } ) f ( y _ { k } ) } { \sum _ { k \in \mathcal { B } _ { y , 3 } ( x _ { j } ) } w ( y _ { k } , x _ { j } ) } , \mathrm { ~ w h e r e ~ } w ( y _ { k } , x _ { j } ) = \frac { 1 } { | | y _ { k } - x _ { j } | | ^ { 2 } } ,
+$$
+
+$f ( y _ { k } )$ and $f ( x _ { j } )$ are features at $y _ { k }$ and $x _ { j }$ , respectively. We can see that the value of $f ( x _ { j } )$ is determined by the relative distances between itself and its three nearest neighbors. However, in 3D space, the point that has a specific relative distances to three fixed points is not unique. In fact, the point can move freely on a curve.
+
+Let’s take a very simple example, assume the three nearest neighbors of $x _ { j }$ forms a regular triangle. If we move $x _ { j }$ along the straight line that passes the center of the triangle and is perpendicular to the plane determined by the triangle, then $x _ { j }$ will always have the same relative distances from the three points, which means $x _ { j }$ will always have the same interpolated feature, as long as its movement is small enough that its three nearest neighbors do not change.
+
+This property makes the three interpolation operation not able to distinguish some specific points in a small scale, since these points could have the same interpolated value. Therefore, three interpolation operation is not suitable for our task, as we need to accurately manipulate positions of points to make them form a meaningful shape with smooth surfaces and sharp details.
+
+# B EXPERIMENT
+
+# B.1 DETAILED EXPERIMENTAL SETUP
+
+In all experiments, we use the Adam optimizer with a learning rate of $2 \times 1 0 ^ { - 4 }$ . For experiments of our PDR paradigm in Table 1 and Table 2 in the main text, we use data augmentation described in Appendix Section B.3. We train our Conditional Generation Network for 340 epochs, 200 epochs, and 500 epochs on the MVP, MVP-40, and Completion3D datasets, respectively. We save a checkpoint and evaluate the network’s performance on both the training set and the test set every 20 epochs. Since the generation process of DDPM is very slow, we randomly select 1600 samples from the training set and test set respectively for evaluation. (Test set of the Completion3D dataset has less than 1600 samples. Therefore, we use all samples in the test set for evaluation.) The checkpoint with the lowest CD loss is chosen as the best network. It is used to generate training data for the Refinement Network. We train the Refinement Network for 100 epochs, 150 epochs and 200 epochs on the MVP, MVP-40, and Completion3D datasets, respectively.
+
+Note that we subsampling the test set only when we try to choose a best checkpoint in the training process of the conditional generation network in DDPM. After choosing the best checkpoint, we use it to generate training data to train the refinement network. However, when we evaluate the whole PDR paradigm (composed of the conditional generation network and refinement network) and compare with previous methods, we evaluate them on the complete test set. Therefore, the comparison result in Table 1 and Table 2 in the main text is reliable and fair.
+
+For ablation studies in Table 3, the Conditional Generation Networks are trained without data augmentation for 300 epochs. All the Refinement Networks are trained on the same data generated by our proposed Conditional Generation Network trained with data augmentation. The Refinement Networks are trained for 100 epochs.
+
+All baseline methods are rerun under the data augmentation described in Appendix Section B.3 according to their open source codes. And CD loss is chosen to train all the baseline methods.
+
+![](images/3c5ba8447d2fdb54f68232b26fea4d7a21989fd5a1a1e2ef83ecf9924a16a235.jpg)  
+Figure 6: Detailed network structure.
+
+# B.2 DETAILS OF THE NETWORK STRUCTURE.
+
+Detailed network structure is shown in Figure 6. We present the number of points and feature dimension in each level of the Feature Extraction network and the Denoise network. The distances to define neighbors are provided in Appendix Section A.2.
+
+# B.3 DATA AUGMENTATION
+
+We use rotation, mirror, translation, and scaling as data augmentation methods during training. Rotation is performed along the upward direction of the shapes. The upward direction is the $y$ -axis in MVP dataset and Completion3D dataset, while upward direction in the MVP-40 dataset is the $z$ - axis. And the rotation angle is uniformly sampled from the interval $[ - a , a ]$ , where $a$ is a predefined hyper-parameter that controls the magnitude of the rotation.
+
+Mirror operation is performed with respect to the two planes that are parallel to the upward direction: $x = 0$ plane and $z = 0$ plane for MVP dataset and Completion3D dataset, $x = 0$ plane and $y = 0$ plane for MVP-40 dataset. The mirror operation is performed with a probability of $m / 2$ with respect to the two planes, respectively. $m$ is a predefined hyper-parameter the controls the probability of the mirror operation.
+
+Same as some previous works (Wang et al., 2020; Xia et al., 2021), we observe that most objects in the MVP dataset and Completion3D dataset have reflection symmetry with respect to the $x y$ plane. Therefore, we mirror the partial input with respect to this plane and concatenate the mirrored points with the original partial input for these two datasets. We subsample this concatenated point cloud from 4096 points to 3072 points by farthest point sampling to obtain a uniform point cloud. We label the original points with 1 and the mirrored points with $- 1$ . This concatenated point cloud is feed to both the Conditional Generation Network and the Refinement Network, so that they could learn whether an object has reflection symmetry and determine whether to utilize the mirrored points according to their $- 1$ label.
+
+Translation is achieved by adding a randomly sampled 3D vector to every point in the incomplete point cloud and the complete point cloud. Each component of the 3D translation vector is sampled from a Gaussian distribution with zero mean and standard deviation of $\sigma$ , where $\sigma$ is a predefined hyper-parameter the controls the magnitude of the translation operation.
+
+We also randomly samples a scaling factor uniformly from the interval $[ \delta _ { l o w } , \delta _ { h i g h } ]$ when loading a training pair. The scaling factor is multiplied to the coordinates of all points in the incomplete point cloud and the complete point cloud.
+
+We observe that data augmentations can prevent the network from overfitting on the training set, but could also lead to performance drop on the test set. Therefore, we use different data augmentation schemes to train the Conditional Generation Network in the DDPM and the Refinement Network. When training the Conditional Generation Network, we hope the network does not overfit on the training set, because we need it to generate training samples to train the Refinement Network. Therefore, we use data augmentations of large magnitudes to train the Conditional Generation Network. However, when training the Refinement Network, high performance is the top priority. Therefore, we use data augmentations of small magnitudes to train the Refinement Network. We also use data augmentation to train baseline methods. The data augmentations are the same ones that we use to train the Refinement Network. The details of the data augmentation is shown in Table 4.
+
+Table 4: Data augmentations used in MVP, MVP-40 and Completion3D dataset by the conditional generation network, refinement network, and all baselines.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">Conditional Generation Network</td><td colspan="4">Refinement Network and other Baselines</td></tr><tr><td>Rotation</td><td>Mirror</td><td>Translation</td><td>Scaling</td><td>Rotation</td><td>Mirror</td><td>Translation</td><td>Scaling</td></tr><tr><td>MVP</td><td>a =90°</td><td>m =0.5</td><td>σ=0.1</td><td>[1/1.2,1.2]</td><td>a=3°</td><td>m=0.5</td><td>σ = 0.005</td><td>[1/1.01,1.01]</td></tr><tr><td>MVP-40</td><td>a=0°</td><td>m = 0.5</td><td>σ=0</td><td>[1/1.2,1.2]</td><td>a =3°</td><td>m = 0.5</td><td>g= 0.005</td><td>[1/1.01,1.01]</td></tr><tr><td>Completion3D</td><td>a =10°</td><td>m =0.2</td><td>σ= 0.01</td><td>[0.66,1]</td><td>a=3°</td><td>m=0.1</td><td>σ = 0.005</td><td>[0.66,1]</td></tr></table>
+
+# B.4 SCALE-INCONSISTENCY ISSUE OF THE COMPLETION3D DATASET
+
+We find that many pairs of incomplete-complete point clouds have inconsistent scales in the Completion3D dataset. A few inconsistent examples are shown in Figure 7. Ideally, the incomplete point should overlap with the complete point cloud in 3D space, but many incomplete-complete pairs in the Completion3D dataset cannot overlap with each other due to inconsistent scales, which misleads the network training. Moreover, the scale-inconsistency issue also gives rise to unreliable evaluation results, as we expect the network to predict a complete point cloud of a consistent scale with the incomplete point cloud. Therefore, it is necessary to correct the scales of these pairs before using the dataset.
+
+![](images/ac957d9ba25772fa06f7a4d95381a3b77e98cbe8cd93574a843b690de33f697e.jpg)  
+Figure 7: The first row shows some inconsistent pairs of the incomplete point cloud and complete point cloud from the Completion3D dataset. The second row are the corrected pairs by minimizing the one-side CD loss.
+
+We leverage the one-side CD loss to identify and correct these pairs. For a consistent pair of the incomplete point cloud $C$ and complete point cloud $\boldsymbol { X }$ , the one-side CD loss should be very low:
+
+$$
+\mathcal { L } _ { \mathrm { 1 - S i d e C D } } ( C , X ) = \frac { 1 } { | C | } \sum _ { c \in C } \operatorname* { m i n } _ { x \in X } | | c - x | | ^ { 2 } .
+$$
+
+We find the correct scale of the incomplete point cloud by optimizing the following problem
+
+$$
+\operatorname* { m i n } _ { \delta } \mathcal { L } _ { \mathrm { 1 - S i d e } \mathrm { C D } } ( \delta C , X ) .
+$$
+
+This optimization problem is solved by using the python package scipy.optimize.fmin for every pair of point clouds in the Completion3D dataset. We consider the pairs with a scale factor $\delta$ greater than 1.05 or less than 0.95 as inconsistent pairs, and then correct its scale inconsistency by multiplying the scale factor $\delta$ to these incomplete point clouds. In the training set, we find $2 . { \dot { 8 } } 1 \%$ pairs are inconsistent. The inconsistent pairs are also discovered in the validation set. We can not verify the test set because the ground truth complete point cloud is not released.
+
+We did not use the online Completion3D benchmark server to evaluate our method and previous methods for the following reasons: 1) the website server was out of service, as it gave no feedback for any submissions at the time we conduct this work; 2) the ground truth complete point clouds in test set of the Completion3D dataset are not released, and hence we can not verify whether this inconsistency problem is also present in the test set. Therefore, we use the test set provided in the work (Wang et al., 2020), which contains 1200 pairs of incomplete-complete point clouds for testing. It contains the same set of objects as the test set of the original Completion3D dataset. After correcting inconsistent pairs in this test set, we evaluate our method and previous methods on this revised test set to achieve fair and reliable comparisons.
+
+# B.5 COMPLETE EXPERIMENT RESULTS FOR MVP-40 DATASET
+
+In Table 1 in the main text, we only present the completion result at the missing ratio of $50 \%$ and $12 . 5 \%$ for the MVP-40 dataset. We present the complete experiment result on MVP-40 dataset including result at the $2 5 \%$ missing ratio in Table 5 below.
+
+Table 5: Complete Point cloud completion results on MVP-40 dataset. The missing ratio is at $50 \%$ $2 5 \%$ and $1 2 . 5 \%$ , respectively. CD loss is multiplied by $1 0 ^ { 4 }$ . EMD loss is multiplied by $1 0 ^ { 2 }$ .   
+
+<table><tr><td rowspan=2 colspan=6>Method</td><td rowspan=1 colspan=1>MVP40 (50% missing)</td><td rowspan=1 colspan=1>MVP40 (25%6missing)</td><td rowspan=1 colspan=1>MVP40 (12.5% missing)</td></tr><tr><td rowspan=1 colspan=1>CD   EMD    F1</td><td rowspan=1 colspan=1>CD   EMD    F1</td><td rowspan=1 colspan=1>CD  EMD     F1</td></tr><tr><td rowspan=3 colspan=6>PCN (Yuan et al., 2018)TopNet (Tchapmi et al., 2019)FoldingNet (Yang et al., 2018)</td><td rowspan=1 colspan=1>39.67 6.37  0.581</td><td rowspan=1 colspan=1>34.40 6.21  0.606</td><td rowspan=1 colspan=1>32.566.18   0.619</td></tr><tr><td rowspan=1 colspan=1>48.52 8.75  0.506</td><td rowspan=1 colspan=1>42.3910.25 0.520</td><td rowspan=1 colspan=1>40.129.08   0.542</td></tr><tr><td rowspan=1 colspan=1>51.8911.66 0.441</td><td rowspan=1 colspan=1>45.99 9.85  0.475</td><td rowspan=1 colspan=1>46.038.93   0.480</td></tr><tr><td rowspan=3 colspan=3>MSN (Liu et al., 2020)Cascade (Wang et al., 2020)ECG (Pan,2020)</td><td rowspan=2 colspan=3>MSN (Liu et al., 2020)Cascade (Wang et al., 2020)</td><td rowspan=1 colspan=1>34.33 9.70  0.646</td><td rowspan=1 colspan=1>23.14 6.59  0.712</td><td rowspan=1 colspan=1>20.204.54   0.728</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>34.1615.40 0.635</td><td rowspan=1 colspan=1>29.13 8.16  0.647</td><td rowspan=1 colspan=1>26.735.71   0.657</td></tr><tr><td rowspan=1 colspan=3>ECG (Pan,2020)</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>34.0616.19 0.671</td><td rowspan=1 colspan=1>28.01 10.79 0.717</td><td rowspan=1 colspan=1>16.906.20   0.774</td></tr><tr><td rowspan=3 colspan=6>GRNet (Xie et al.,2020)PMPNet (Wen et al., 2021)VRCNet (Pan et al.,2021)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>35.9912.33 0.589</td><td rowspan=1 colspan=1>25.84 8.43  0.626</td></tr><tr><td rowspan=2 colspan=1>25.4129.92 0.72125.7018.40 0.736</td><td rowspan=1 colspan=1>15.73 16.08 0.815</td><td rowspan=1 colspan=1>13.008.92   0.815</td></tr><tr><td rowspan=1 colspan=1>18.2810.96 0.776</td><td rowspan=1 colspan=1>14.205.90   0.807</td></tr><tr><td rowspan=1 colspan=6>PDR paradigm (Ours)</td><td rowspan=1 colspan=1>27.20 2.68  0.739</td><td rowspan=1 colspan=1>16.54 1.68  0.800</td><td rowspan=1 colspan=1>12.701.39  0.827</td></tr></table>
+
+B.6 COMPLETE EXPERIMENT RESULTS FOR NETWORK ABLATION STUDY
+
+Table 6: Comparison of coarse point clouds generated by conditional generation networks of different structures on MVP dataset at the resolution of 2048 points. Experiments are conducted under two circumstances: with and without data augmentation. The networks without data augmentation are trained for 300 epochs, and networks with data augmentation are trained for 600 epochs. The data augmentation we use is specified in Table 4 for the MVP dataset. We report the networks’ performance on both the training set and the test set. We can see the overfitting problem is largely mitigated by data augmentation.   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=3>DataAugmentation</td><td rowspan=1 colspan=1>CD</td><td rowspan=1 colspan=1>EMD</td><td rowspan=1 colspan=1>F1</td></tr><tr><td rowspan=1 colspan=1>Train Test</td><td rowspan=1 colspan=1>TrainTest</td><td rowspan=1 colspan=1>Train Test</td></tr><tr><td rowspan=1 colspan=1>Pointwise-netConcate xt &amp; cPointNet++PA-DeconvPA-Deconv &amp; Att.</td><td rowspan=1 colspan=3>X×XXX</td><td rowspan=1 colspan=1>6.96 11.999.96 10.796.44  9.395.85  8.815.56  8.71</td><td rowspan=1 colspan=1>0.88 1.631.57 1.540.84 1.380.73 1.340.70 1.29</td><td rowspan=1 colspan=1>0.3280.2650.3970.3820.3970.3550.4250.3790.4430.389</td></tr><tr><td rowspan=4 colspan=1>Pointwise-netConcate xt &amp;cPointNet++PA-DeconvPA-Deconv &amp; Att.</td><td rowspan=1 colspan=3>√√</td><td rowspan=1 colspan=1>11.3012.6914.5216.31</td><td rowspan=1 colspan=1>1.33 1.611.90 1.99</td><td rowspan=1 colspan=1>0.2620.2460.4140.395</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>【</td><td rowspan=1 colspan=1>9.86 11.18</td><td rowspan=1 colspan=1>1.43 1.74</td><td rowspan=1 colspan=1>0.4020.376</td></tr><tr><td rowspan=2 colspan=3>←&lt;</td><td rowspan=1 colspan=1>←</td><td rowspan=1 colspan=1>9.22 10.78</td><td rowspan=1 colspan=1>1.24 1.50</td><td rowspan=1 colspan=1>0.4070.381</td></tr><tr><td rowspan=1 colspan=1>7.98  9.24</td><td rowspan=1 colspan=1>1.03 1.32</td><td rowspan=1 colspan=1>0.4360.409</td></tr></table>
+
+In Section 5.3 in the main text, we conduct ablation study of our proposed network architecture, and results are shown in Table 3. Note that the conditional generation networks in DDPM in Table 3 are trained without data augmentation. However, it is actually very important to train the conditional generation networks with data augmentation, because we need to prevent it from overfitting on the training set, so that they can generate coarse point clouds of consistent distribution on the training set and test set to train the refinement network. Therefore, we provide the training results with data augmentation in Table 6. The data augmentation is specified in Table 4 for MVP dataset.
+
+Same as Table 3 in the main text, “PA-Deonv & Att.” is our proposed complete network shown in Figure 2. “PA-Deonv” is our network without attention mechanism. “PointNet $+ + { } ^ { \because }$ further removes the PA-Deconv module. “Concate $\mathbf { \boldsymbol { x } } ^ { t }$ & $c ^ { \prime \prime }$ removes FT modules. It concatenates $^ c$ with $\mathbf { \boldsymbol { x } } ^ { t }$ as Zhou et al. (2021) do, and feed them to a single PointNe $^ { + + }$ with attention mechanism and PA-Deconv. “Pointwise-net” only utilizes a global feature extracted from the incomplete point cloud. We can see that these proposed modules indeed improve the networks’ performance. Our proposed networks achieve superior results both with and without data augmentation.
+
+We also observe that networks generally achieve better performance on both the training set and test set without data augmentation, but they tend to overfit on the training set. This is undesirable because we need these conditional generation networks to generate training data for the refinement networks. It is very important for them to generate coarse point clouds that have consistent distributions on the training set and the test set. Indeed, we can see that the overfitting problem is largely mitigated in the presence of data augmentation.
+
+# B.7 COMPLETE EXPERIMENT RESULTS FOR DDPM ACCELERATION
+
+The complete experiment results of the DDPM acceleration is shown in Table 7. We can see that the quality of coarse point clouds generated by the accelerated DDPMs has dropped considerably. However, with the help of the Refinement Network, the performance drop of the final refined point clouds is slight. This demonstrates the strong refinement capability of our proposed network architecture shown in Figure 2 in the main text.
+
+Table 7: Refine coarse point clouds generated by the accelerated DDPMs on the MVP dataset at the resolution of 2048 points. We can see performance drop is slight for the refined point clouds. We also report the average generation time of a single point cloud evaluated on one NVIDIA GEFORCE RTX 2080 Ti GPU for DDPM of different reverse steps.   
+
+<table><tr><td rowspan="2">Number of Reverse Steps</td><td rowspan="2">Average Generation Time</td><td colspan="2">CD</td><td colspan="2">EMD</td><td colspan="2">F1</td></tr><tr><td>Coarse</td><td>Refined</td><td>Coarse</td><td>Refined</td><td>Coarse</td><td>Refined</td></tr><tr><td>1000 (Original)</td><td>16.86 s</td><td>10.69</td><td>5.66</td><td>1.46</td><td>1.37</td><td>0.400</td><td>0.499</td></tr><tr><td>50</td><td>0.78 s</td><td>13.19</td><td>5.68</td><td>1.65</td><td>1.47</td><td>0.341</td><td>0.493</td></tr><tr><td>20</td><td>0.32 s</td><td>18.12</td><td>5.78</td><td>1.99</td><td>1.56</td><td>0.255</td><td>0.474</td></tr></table>
+
+![](images/ebdb069aac1e105de51590d4892604e90675e91ce361c84ec74c058868ee4cdf.jpg)  
+Figure 8: Our PDR paradigm demonstrates diversity in the completion results. For each object, the two images in the first row are coarse completion results from a trained DDPM generated in two trials for the same incomplete point cloud. The two images in the second row are refined results for the two coarse point clouds, respectively. We can see that some diversity is preserved after the refinement.
+
+# B.8 GENERATION DIVERSITY OF THE PDR PARADIGM
+
+In this section, we discuss whether the PDR Paradigm can generate diverse completion results for the same incomplete point cloud. Although there is no stochasticity in the refinement network, we find our PDR paradigm still demonstrates some kind of diversity in the completion results.
+
+We know that DDPM itself is a probabilistic model and can generate diverse completion results. The refinement network receives a coarse completion from the DDPM and then refines it according to the condition point cloud, i.e., the incomplete point cloud. The final refined result surely depends on the condition point cloud, but also depends on the coarse point cloud received from the DDPM. The refinement network can only refine the coarse point cloud in a small scale, because we multiply the output of the refinement network by a small constant $\gamma = 0 . 0 0 1$ as described in Section 3.3 in the main text. Therefore, the overall sketch of the coarse point cloud will be preserved after the refinement. This explains why the PDR paradigm still bears low EMD loss as the DDPM, even though we use CD loss to train the refinement network, because the refinement network does not change the overall distribution of the coarse shape generated by DDPM.
+
+Back to the diversity issue, if the coarse completion results from DDPM demonstrate diversity for the same incomplete point cloud, the refined point clouds will also demonstrate some diversity because the inputs to the refinement network are different. Figure 8 shows some examples where the PDR paradigm demonstrate diversity in the completion results.
+
+![](images/7dc2b01b9e116f38475b01ec60a451c327b6f33938df01845266cbf47addfbfa.jpg)  
+Figure 9: Visual comparison of our method and other baselines. Samples are from the MVP dataset at the resolution of 16384 points. We can see that point clouds generated by our method generally have better visual quality.
+
+![](images/5519f64203aab21d0748ea1c0027497214c131a089482db1489ab48b5aa23b03.jpg)  
+Figure 10: Visual comparison of our method and VRCNet. Samples are from the MVP dataset at the resolution of 16384 points. We can see that VRCNet sometimes tend to predict more points to the parts that are known in the incompelte point cloud, while put less points at the missing part. This could effectively reduce CD loss, but leads to large EMD loss. Compared with VRCNet, our method generally generates more uniform point clouds.
+
+![](images/ba5f5f51d1d0dd9ed8564cb0736d88ed93de4815984e45ec3cbc72656cdf5f4f.jpg)  
+Figure 11: Visual comparison of our method and PoinTr. Samples are from the MVP dataset at the resolution of 16384 points. We can see that PoinTr sometimes tend to predict more points at the skeleton of objects, while points on surfaces seem sparse. Compared with PoinTr, our method generally generates more uniform point clouds.
+
+![](images/fb18d39234c7bacfc53ce62fcc2930ffcd7811f5615dfba7f0fe0befe8f1a2a4.jpg)  
+Figure 12: Visual comparison of coarse point clouds generated by the Conditional Generation Network in DDPM and point clouds after refinement. Samples are from the MVP dataset at the resolution of 2048 points. We can see that coarse point clouds generated by the Conditional Generation Network basically uniformly cover the overall shape of objects, but tend to be noisy. After refinement, point clouds demonstrate both good overall density distribution and sharp local details.