Add files using upload-large-folder tool

parse/train/B1xSperKvH/B1xSperKvH.md

@@ -0,0 +1,252 @@
+# ENABLING DEEP SPIKING NEURAL NETWORKSWITH HYBRID CONVERSION AND SPIKE TIMINGDEPENDENT BACKPROPAGATION
+
+Nitin Rathi1, Gopalakrishnan Srinivasan1, Priyadarshini Panda2 & Kaushik Roy1
+
+1School of Electrical and Computer Engineering, Purdue University 2Department of Electrical Engineering, Yale University {rathi2, srinivg}@purdue.edu, priya.panda@yale.edu, kaushik@purdue.edu
+
+# ABSTRACT
+
+Spiking Neural Networks (SNNs) operate with asynchronous discrete events (or spikes) which can potentially lead to higher energy-efficiency in neuromorphic hardware implementations. Many works have shown that an SNN for inference can be formed by copying the weights from a trained Artificial Neural Network (ANN) and setting the firing threshold for each layer as the maximum input received in that layer. These type of converted SNNs require a large number of time steps to achieve competitive accuracy which diminishes the energy savings. The number of time steps can be reduced by training SNNs with spike-based backpropagation from scratch, but that is computationally expensive and slow. To address these challenges, we present a computationally-efficient training technique for deep SNNs1. We propose a hybrid training methodology: 1) take a converted SNN and use its weights and thresholds as an initialization step for spike-based backpropagation, and 2) perform incremental spike-timing dependent backpropagation (STDB) on this carefully initialized network to obtain an SNN that converges within few epochs and requires fewer time steps for input processing. STDB is performed with a novel surrogate gradient function defined using neuron’s spike time. The weight update is proportional to the difference in spike timing between the current time step and the most recent time step the neuron generated an output spike. The SNNs trained with our hybrid conversion-and-STDB training perform at $1 0 \times - 2 5 \times$ fewer number of time steps and achieve similar accuracy compared to purely converted SNNs. The proposed training methodology converges in less than 20 epochs of spike-based backpropagation for most standard image classification datasets, thereby greatly reducing the training complexity compared to training SNNs from scratch. We perform experiments on CIFAR-10, CIFAR-100 and ImageNet datasets for both VGG and ResNet architectures. We achieve top-1 accuracy of $6 5 . 1 9 \%$ for ImageNet dataset on SNN with 250 time steps, which is $1 0 \times$ faster compared to converted SNNs with similar accuracy.
+
+# 1 INTRODUCTION
+
+In recent years, Spiking Neural Networks (SNNs) have shown promise towards enabling low-power machine intelligence with event-driven neuromorphic hardware. Founded on bio-plausibility, the neurons in an SNN compute and communicate information through discrete binary events (or spikes) a significant shift from the standard artificial neural networks (ANNs), which process data in a real-valued (or analog) manner. The binary all-or-nothing spike-based communication combined with sparse temporal processing precisely make SNNs a low-power alternative to conventional ANNs. With all its appeal for power efficiency, training SNNs still remains a challenge. The discontinuous and non-differentiable nature of a spiking neuron (generally, modeled as leaky-integrate-and-fire (LIF), or integrate-and-fire (IF)) poses difficulty to conduct gradient descent based backpropagation. Practically, SNNs still lag behind ANNs, in terms of performance or accuracy, in traditional learning tasks. Consequently, there has been several works over the past few years that propose different learning algorithms or learning rules for implementing deep convolutional SNNs for complex visual recognition tasks (Wu et al., 2019; Hunsberger & Eliasmith, 2015; Cao et al., 2015). Of all the techniques, conversion from ANN-to-SNN (Diehl et al., 2016; 2015; Sengupta et al., 2019; Hunsberger & Eliasmith, 2015) has yielded state-of-the-art accuracies matching deep ANN performance for Imagenet dataset on complex architectures (such as, VGG (Simonyan & Zisserman, 2014) and ResNet (He et al., 2016) ). In conversion, we train an ANN with ReLU neurons using gradient descent and then convert the ANN to an SNN with IF neurons by using suitable threshold balancing (Sengupta et al., 2019). But, SNNs obtained through conversion incur large latency of 2000−2500 time steps (measured as total number of time steps required to process a given input image2). The term ‘time step’ defines an unit of time required to process a single input spike across all layers and represents the network latency. The large latency translates to higher energy consumption during inference, thereby, diminishing the efficiency improvements of SNNs over ANNs. To reduce the latency, spike-based backpropagation rules have been proposed that perform end-to-end gradient descent training on spike data. In spike-based backpropagation methods, the non-differentiability of the spiking neuron is handled by either approximating the spiking neuron model as continuous and differentiable (Huh & Sejnowski, 2018) or by defining a surrogate gradient as a continuous approximation of the real gradient (Wu et al., 2018; Bellec et al., 2018; Neftci et al., 2019). Spike-based SNN training reduces the overall latency by ${ \sim } 1 0 \times$ (for instance, $2 0 0 \mathrm { ~ - ~ } 2 5 0$ time steps required to process an input (Lee et al., 2019)) but requires more training effort (in terms of total training iterations) than conversion approaches. A single feed-forward pass in ANN corresponds to multiple forward passes in SNN which is proportional to the number of time steps. In spike-based backpropagation, the backward pass requires the gradients to be integrated over the total number of time steps that increases the computation and memory complexity. The multiple-iteration training effort with exploding memory requirement (for backward pass computations) has limited the applicability of spike-based backpropagation methods to small datasets (like CIFAR10) on simple few-layered convolutional architectures.
+
+In this work, we propose a hybrid training technique which combines ANN-SNN conversion and spike-based backpropagation that reduces the overall latency as well as decreases the training effort for convergence. We use ANN-SNN conversion as an initialization step followed by spike-based backpropagation incremental training (that converges to optimal accuracy with few epochs due to the precursory initialization). Essentially, our hybrid approach of taking a converted SNN and incrementally training it using backpropagation yields improved energy-efficiency as well as higher accuracy than a model trained from scratch with only conversion or only spike-based backpropagation.
+
+In summary, this paper makes the following contributions:
+
+• We introduce a hybrid computationally-efficient training methodology for deep SNNs. We use the weights and firing thresholds of an SNN converted from an ANN as the initialization step for spike-based backpropagation. We then train this initialized network with spike-based backpropagation for few epochs to perform inference at a reduced latency or time steps. We propose a novel spike time-dependent backpropagation (STDB, a variant of standard spike-based backpropagation) that computes surrogate gradient using neuron’s spike time. The parameter update is triggered by the occurrence of spike and the gradient is computed based on the time difference between the current time step and the most recent time step the neuron generated an output spike. This is motivated from the Hebb’s principle which states that the plasticity of a synapse is dependent on the spiking activity of the neurons connected to the synapse. Our hybrid approach with the novel surrogate gradient descent allows training of large-scale SNNs without exploding memory required during spike-based backpropagation. We evaluate our hybrid approach on large SNNs (VGG, ResNet-like architectures) on
+
+Imagenet, CIFAR datasets and show near iso-accuracy compared to similar ANNs and converted SNNs at lower compute cost and energy.
+
+# 2 SPIKE TIMING DEPENDENT BACKPROPAGATION (STDB)
+
+In this section, we describe the spiking neuron model, derive the equations for the proposed surrogate gradient based learning, present the weight initialization method for SNN, discuss the constraints applied for ANN-SNN conversion, and summarize the overall training methodology.
+
+# 2.1 LEAKY INTEGRATE AND FIRE (LIF) NEURON MODEL
+
+The neuron model defines the dynamics of the neuron’s internal state and the trigger for it to generate a spike. The differential equation
+
+$$
+\tau \frac { d U } { d t } = - ( U - U _ { r e s t } ) + R I
+$$
+
+![](images/7c4a28ea13d64064dc648e47aca903dfa249118653d5d33be93a1c4056719f2e.jpg)  
+Figure 1: Surrogate gradient of the spiking neuron activation function (Eq. 11). $\alpha = 0 . 3 , \beta = 0 . 0 1$ . The gradient is computed for each neuron and $\Delta t$ defines the time difference between current simulation time and the last spike time of the neuron. For example, if a neuron spikes at $t _ { s } = 1 2$ its gradient will be maximum at $t = 1 2 ( \Delta t = 0 )$ and gradually decrease for later time steps. If the same neuron spikes later at $t _ { s } = 2 4$ its previous spike history will be overwritten and the gradient computation for $t = 2 4$ onward will only consider the most recent spike. This avoids the overhead of storing all the spike history in memory.
+
+is widely used to characterize the leaky-integrate-and-fire (LIF) neuron model where, $U$ is the internal state of the neuron referred as the membrane potential, $U _ { r e s t }$ is the resting potential, $R$ and $I$ are the input resistance and the current, respectively. The above equation is valid when the membrane potential is below the threshold value $( V )$ . The neuron geneartes an output spike when $U { \geqslant } V$
+
+and $U$ is reduced to the reset potential. This representation is described in continuous domain and more suitable for biological simulations. We modify the equation to be evaluated in a discrete manner in the Pytorch framework ( $\mathrm { W u }$ et al., 2018). The iterative model for a single post-neuron is described by
+
+$$
+u _ { i } ^ { t } = \lambda u _ { i } ^ { t - 1 } + \sum _ { j } w _ { i j } o _ { j } ^ { t } - v o _ { i } ^ { t - 1 }
+$$
+
+$$
+o _ { i } ^ { t - 1 } = \left\{ { \begin{array} { l l } { 1 , } & { { \mathrm { i f ~ } } u _ { i } ^ { t - 1 } > v } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } } \end{array} } \right.
+$$
+
+where $u$ is the membrane potential, subscript $i$ and $j$ represent the post- and pre-neuron, respectively, superscript $t$ is the time step, $\lambda$ is a constant $( < 1 )$ responsible for the leak in membrane potential, $w$ is the weight connecting the pre- and post-neuron, $o$ is the binary output spike, and $v$ is the firing threshold potential. The right hand side of Equation 2 has three terms: the first term calculates the leak in the membrane potential from the previous time step, the second term integrates the input from the previous layer and adds it to the membrane potential, and the third term which is outside the summation reduces the membrane potential by the threshold value if a spike is generated. This is known as soft reset as the membrane potential is lowered by $v$ compared to hard reset where the membrane potential is reduced to the reset value. Soft reset enables the spiking neuron to carry forward the excess potential above the firing threshold to the following time step, thereby minimizing information loss.
+
+<table><tr><td>Algorithm 1 ANN-SNN conversion: initialization of weights and threshold voltages Input: Trained ANN model (A), SNN model (N), Input (X) // Copy ann weights to snn</td></tr><tr><td>for l=1 to L do |Ni.W ← A.W end // Initialize threshold voltage to O V ←[0,·…·,0]L-1 for l=1 to L-1 do c↑0 for t=1 to T do</td></tr><tr><td>Ot ← PoissonGenerator(X) for k=1 to l do ifk&lt;l then // Forward (Algorithm 3) end</td></tr><tr><td>else // Pre-nonlinearity (A) A ← Nt(O-1) if max(A) &gt; v then v ←max(A) end end end</td></tr></table>
+
+<table><tr><td>Algorithm 2 Initialize the neuron parameters. Membrane potential (U),last spike time(S), dropout mask (M).The initialization is performed once for everymini-batch.</td></tr><tr><td>Input: Input(X), network model(N) b_size=X.b_size h=X.height w=X.width for l=1 to L do</td></tr><tr><td>if isintance(Ni,Conv) then Ut = zeros(b_size,Ni.out,h,w) St = ones(b_size,Ni.out,h,w) * (-1000) end elseif isintance(Nt,Linear) then Ut = zeros(b_size,Ni.out) St = ones(b_size,Ni.out) *(-1000)</td></tr><tr><td>end else if isintance(Ni,Dropout) then // Generate the dropout map that will be fixed for all time steps Mt = Ni(ones(Ut-1.shape)) end else ifisintance(Ni,AugPool) then //Reduce the width and height after average pooling layer h=h//kernel_size w=w//kernel_size end</td></tr></table>
+
+# 2.2 SPIKE TIMING DEPENDENT BACKPROPAGATION (STDB) LEARNING RULE
+
+The neuron dynamics (Equation 2) show that the neuron’s state at a particular time step recurrently depends on its state in previous time steps. This introduces implicit recurrent connections in the network (Neftci et al., 2019). Therefore, the learning rule has to perform the temporal credit assignment along with the spatial credit assignment. Credit assignment refers to the process of assigning credit or blame to the network parameters according to their contribution to the loss function. Spatial credit assignment identifies structural network parameters (like weights), whereas temporal credit assignment determines which past network activities contributed to the loss function. Gradient-descent learning solves both credit assignment problem: spatial credit assignment is performed by distributing error spatially across all layers using the chain rule of derivatives, and temporal credit assignment is done by unrolling the network in time and performing backpropagation through time (BPTT) using the same chain rule of derivatives (Werbos et al., 1990). In BPTT, the network is unrolled for all time steps and the final output is computed as the sum of outputs from each time step. The loss function is defined on the summed output.
+
+The dynamics of the neuron in the output layer is described by Equation (4), where the leak part is removed $\lambda = 1$ ) and the neuron only integrates the input without firing. This eliminates the difficulty of defining the loss function on spike count (Lee et al., 2019).
+
+$$
+u _ { i } ^ { t } = u _ { i } ^ { t - 1 } + \sum _ { j } w _ { i j } o _ { j }
+$$
+
+The number of neurons in the output layer is the same as the number of categories in the classification task. The output of the network is passed through a softmax layer that outputs a probability distribution. The loss function is defined as the cross-entropy between the true output and the
+
+network’s predicted distribution.
+
+$$
+\begin{array} { c } { L = - \displaystyle \sum _ { i } y _ { i } l o g ( p _ { i } ) } \\ { p _ { i } = \displaystyle \frac { e ^ { u _ { i } ^ { T } } } { \sum _ { k = 1 } ^ { N } e ^ { u _ { k } ^ { T } } } } \end{array}
+$$
+
+$L$ is the loss function, $y$ the true output, $p$ the prediction, $T$ the total number of time steps, $u ^ { T }$ the accumulated membrane potential of the neuron in the output layer from all time steps, and $N$ the number of categories in the task. For deeper networks and large number of time steps the truncated version of the BPTT algorithm is used to avoid memory issues. In the truncated version the loss is computed at some time step $t ^ { \prime }$ before $\mathrm { T }$ based on the potential accumulated till $t ^ { \prime }$ . The loss is backpropagated to all layers and the loss gradients are computed and stored. At this point, the history of the computational graph is cleaned to save memory. The subsequent computation of loss gradients at later time steps $( 2 t ^ { \prime } , 3 t ^ { \prime } , . . . T )$ are summed together with the gradient at $t ^ { \prime }$ to get the final gradient. The optimizer updates the parameters at $T$ based on the sum of the gradients. Gradient descent learning has the objective of minimizing the loss function. This is achieved by backpropagating the error and updating the parameters opposite to the direction of the derivative. The derivative of the loss function w.r.t. to the membrane potential of the neuron in the final layer is described by,
+
+$$
+\frac { \partial L } { \partial u _ { i } ^ { T } } = p _ { i } - y _ { i }
+$$
+
+To compute the gradient at current time step, the membrane potential at last time step $( u _ { i } ^ { t - 1 }$ in Equation 4) is considered as an input quantity. Therefore, gradient descent updates the network parameters $W _ { i j }$ of the output layer as,
+
+$$
+W _ { i j } = W _ { i j } - \eta \Delta W _ { i j }
+$$
+
+$$
+\Delta W _ { i j } = \sum _ { t } { \frac { \partial L } { \partial W _ { i j } ^ { t } } } = \sum _ { t } { \frac { \partial L } { \partial u _ { i } ^ { T } } } { \frac { \partial u _ { i } ^ { T } } { \partial W _ { i j } ^ { t } } } = { \frac { \partial L } { \partial u _ { i } ^ { T } } } \sum _ { t } { \frac { \partial u _ { i } ^ { T } } { \partial W _ { i j } ^ { t } } }
+$$
+
+where $\eta$ is the learning rate, and ${ W } _ { i j } ^ { t }$ represents the copy of the weight used for computation at time step $t$ . In the output layer the neurons do not generate a spike, and hence, the issue of non-differentiability is not encountered. The update of the hidden layer parameters is described by,
+
+$$
+\Delta W _ { i j } = \sum _ { t } { \frac { \partial L } { \partial W _ { i j } ^ { t } } } = \sum _ { t } { \frac { \partial L } { \partial o _ { i } ^ { t } } } { \frac { \partial o _ { i } ^ { t } } { \partial u _ { i } ^ { t } } } { \frac { \partial u _ { i } ^ { t } } { \partial W _ { i j } ^ { t } } }
+$$
+
+where $o _ { i } ^ { t }$ is the thresholding function (Equation 3) whose derivative w.r.t to $u _ { i } ^ { t }$ is zero everywhere and not defined at the time of spike. The challenge of discontinuous spiking nonlinearity is resolved by introducing a surrogate gradient which is the continuous approximation of the real gradient.
+
+$$
+\frac { \partial o _ { i } ^ { t } } { \partial u _ { i } ^ { t } } = \alpha e ^ { - \beta \Delta t }
+$$
+
+where $\alpha$ and $\beta$ are constants, $\Delta t$ is the time difference between the current time step $\mathbf { \rho } ( t )$ and the last time step the post-neuron generated a spike $( t _ { s } )$ . It is an integer value whose range is from zero to the total number of time steps $( T )$ .
+
+$$
+\Delta t = ( t - t _ { s } ) , 0 < \Delta t < T , \Delta t \epsilon \mathbb { Z }
+$$
+
+The values of $\alpha$ and $\beta$ are selected depending on the value of $T$ . If $T$ is large $\beta$ is lowered to reduce the exponential decay so a spike can contribute towards gradients for later time steps. The value of $\alpha$ is also reduced for large $T$ because the gradient can propagate through many time steps. The gradient is summed at each time step and thus a large $\alpha$ may lead to exploding gradient. The surrogate gradient can be pre-computed for all values of $\Delta t$ and stored in a look-up table for faster computation. The parameter updates are triggered by the spiking activity but the error gradients are still non-zero for time steps following the spike time. This enables the algorithm to avoid the ‘dead
+
+Algorithm 3 Training an SNN with surrogate gradient computed with spike timing. The network is composed of $L$ layers. The training proceeds with mini-batch size (batch size)
+
+Input: Mini-batch of input $( X )$ - target $( Y )$ pairs, network model $( N )$ , initial weights $( W )$ , threshold voltage $( V )$   
+$U , S , M = I$ nitializeNeuronP arameter $s ( X )$ [Algorithm 2]   
+// Forward propagation   
+for $t { = } I$ to $T$ do $O _ { 0 } ^ { t } = P o i s s o n G e n e r a t o r ( X )$ for $l { = } l$ to L-1 do if isintanc $e ( N _ { l } , [ C o n v , L i n e a r ] )$ then // accumulate the output of previous layer in $U$ , soft reset when spike occurs $\begin{array} { r } { U _ { l } ^ { t } = \lambda U _ { l } ^ { t - 1 } + W _ { l } \dot { O } _ { l - 1 } ^ { t } - V _ { l } * O _ { l } ^ { t - 1 } } \end{array}$ ? // generate the output $( + 1 )$ if $U$ exceeds $V$ $\hat { O _ { l } ^ { t } } = S T D B ( U _ { l } ^ { t } , V _ { l } , t )$ $/ /$ store the latest spike times for each neuron $S _ { l } ^ { t } [ O _ { l } ^ { t } = = 1 ] = t$ end else if isintance ${ \mathrm { : } } ( N _ { l } , A v g P o o l )$ then $O _ { l } ^ { t } = N _ { l } ( O _ { l - 1 } ^ { t } )$ end else if isintance $( N _ { l } , D r o p o u t )$ then $O _ { l } ^ { t } = O _ { l - 1 } ^ { t } * M _ { l }$ end end $U _ { L } ^ { t } = \lambda U _ { L } ^ { t - 1 } + W _ { L } O _ { L - 1 } ^ { t }$   
+end   
+// Backward Propagation   
+Compute $\frac { \partial L } { \partial U _ { L } }$ from the cross-entropy loss function using BPTT   
+for $t { = } T$ to $^ { l }$ do for $\scriptstyle { l = L - I }$ to 1 do Compute $\frac { \partial L } { \partial O _ { l } ^ { t } }$ based on if $N _ { l }$ is linear, conv, pooling, etc. $\begin{array} { r } { \frac { \partial L } { \partial U _ { l } ^ { t } } = \frac { \partial L } { \partial O _ { l } ^ { t } } \frac { \partial O _ { l } ^ { t } } { \partial U _ { l } ^ { t } } = \frac { \partial L } { \partial O _ { l } ^ { t } } \ast \alpha e ^ { - \beta S _ { l } ^ { t } } } \end{array}$ end   
+end
+
+neuron’ problem, where no learning happens when there is no spike. Fig. 1 shows the activation gradient for different values of $\Delta t$ , the gradient decreases exponentially for neurons that have not been active for a long time. In Hebbian models of biological learning, the parameter update is activity dependent. This is experimentally observed in spike-timing-dependent plasticity (STDP) learning rule which modulates the weights for pair of neurons that spike within a time window (Song et al., 2000).
+
+# 3 SNN WEIGHT INITIALIZATION
+
+A prevalent method of constructing SNNs for inference is ANN-SNN conversion (Diehl et al., 2015; Sengupta et al., 2019). Since the network is trained with analog activations it does not suffer from the non-differentiablity issue and can leverage the training techniques of ANNs. The conversion process has a major drawback: it suffers from long inference latency ( $\mathrm { \sim 2 5 0 0 }$ time steps) as mentioned in Section 1. As there is no provision to optimize the parameters after conversion based on spiking activity, the network can not leverage the temporal information of the spikes. In this work, we propose to use the conversion process as an initialization technique for STDB. The converted weights and thresholds serve as a good initialization for the optimizer and the STDB learning rule is applied for temporal and spatial credit assignment.
+
+Algorithm 1 explains the ANN-SNN conversion process. The threshold voltages in SNN needs to be adjusted based on the ANN weights. Sengupta et al. (2019) showed two ways to achieve this: weight-normalization and threshold-balancing. In weight-normalization the weights are scaled by a normalization factor and threshold is set to 1, whereas in threshold-balancing the weights are unchanged and the threshold is set to the normalization factor. Both have a similar effect and either can be used to set the threshold. We employ the threshold-balancing method and the normalization factor is calculated as the maximum output of the corresponding convolution/linear layer in SNN. The maximum is calculated over a mini-batch of input for all time steps.
+
+There are several constraints imposed on training the ANN for the conversion process (Sengupta et al., 2019; Diehl et al., 2015). The neurons are trained without the bias term because the bias term in SNN has an indirect effect on the threshold voltage which increases the difficulty of threshold balancing and the process becomes more prone to conversion loss. The absence of bias term eliminates the use of Batch Normalization (Ioffe & Szegedy, 2015) as a regularizer in ANN since it biases the input of each layer to have zero mean. As an alternative, Dropout (Srivastava et al., 2014) is used as a regularizer for both ANN and SNN training. The implementation of Dropout in SNN is further discussed in Section 5. The pooling operation is widely used in ANN to reduce the convolution map size. There are two popular variants: max pooling and average pooling (Boureau et al., 2010). Max (Average) pooling outputs the maximum (average) value in the kernel space of the neuron’s activations. In SNN, the activations are binary and performing max pooling will result in significant information loss for the next layer, so we adopt the average pooling for both ANN and SNN (Diehl et al., 2015).
+
+# 4 NETWORK ARCHITECTURES
+
+![](images/31821489c1dc4301bde516e227360d788e26a0deac85ccef825dbbbadc225416.jpg)  
+Figure 2: Residual architecture for SNN
+
+In this section, we describe the changes made to the VGG (Simonyan & Zisserman, 2014) and residual architecture (He et al., 2016) for hybrid learning and discuss the process of threshold computation for both the architectures.
+
+# 4.1 VGG ARCHITECTURE
+
+The threshold balancing is performed for all layers except the input and output layer in a VGG architecture. For every hidden convolution/linear layer the maximum input3 to the neuron is computed over all time steps and set as threshold for that layer. The threshold assignment is done sequentially as described in Algorithm 1. The threshold computation for all layers can not be performed in parallel (in one forward pass) because in the forward method (Algorithm 3) we need the threshold at each time step to decide if the neuron should spike or not.
+
+# 4.2 RESIDUAL ARCHITECTURE
+
+Residual architectures introduce shortcut connections between layers that are not next to each other. In order to minimize the ANN-SNN conversion loss various considerations were made by Sengupta et al. (2019). The original residual architecture proposed by He et al. (2016) uses an initial convolution layer with wide kernel $( 7 \times 7$ , stride 2). For conversion, this is replaced by a pre-processing block consisting of a series of three convolution layer $( 3 \times 3$ , stride 1) with dropout layer in between (Fig. 2). The threshold balancing mechanism is applied to only these three layers and the layers in the basic block have unity threshold.
+
+Table 1: Classification results (Top-1) for CIFAR10, CIFAR100 and ImageNet data sets. Column-1 shows the network architecture. Column-2 shows the ANN accuracy when trained under the constraints as described in Section 3. Column-3 shows the SNN accuracy for $T \ : = \ : 2 5 0 0$ when converted from a ANN with threshold balancing. Column-4 shows the performance of the same converted SNN with lower time steps and adjusted thresholds. Column-5 shows the performance after training the Column-4 network with STDB for less than 20 epochs.   
+
+<table><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>ANN</td><td rowspan=1 colspan=1>ANN-SNNConversion(T = 2500)</td><td rowspan=1 colspan=1>ANN-SNNConversion (reduced time steps)</td><td rowspan=1 colspan=1>Hybrid Training(ANN-SNN Conversion+ STDB)</td></tr><tr><td rowspan=1 colspan=5>CIFAR10</td></tr><tr><td rowspan=1 colspan=1>VGG5</td><td rowspan=1 colspan=1>87.88%</td><td rowspan=1 colspan=1>87.64%</td><td rowspan=1 colspan=1>84.56% (T = 75)</td><td rowspan=1 colspan=1>86.91% (T = 75)</td></tr><tr><td rowspan=1 colspan=1>VGG9</td><td rowspan=1 colspan=1>91.45%</td><td rowspan=1 colspan=1>90.98%</td><td rowspan=1 colspan=1>87.31% (T = 100)</td><td rowspan=1 colspan=1>90.54% (T = 100)</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>92.81%</td><td rowspan=1 colspan=1>92.48%</td><td rowspan=1 colspan=1>90.2% (T = 100)</td><td rowspan=1 colspan=1>91.13% (T = 100)</td></tr><tr><td rowspan=1 colspan=1>ResNet8</td><td rowspan=1 colspan=1>91.35%</td><td rowspan=1 colspan=1>91.12%</td><td rowspan=1 colspan=1>89.5% (T = 200)</td><td rowspan=1 colspan=1>91.35% (T = 200)</td></tr><tr><td rowspan=1 colspan=1>ResNet20</td><td rowspan=1 colspan=1>93.15%</td><td rowspan=1 colspan=1>92.94%</td><td rowspan=1 colspan=1>91.12% (T = 250)</td><td rowspan=1 colspan=1>92.22% (T = 250)</td></tr><tr><td rowspan=1 colspan=5>CIFAR100</td></tr><tr><td rowspan=1 colspan=1>VGG11</td><td rowspan=1 colspan=1>71.21%</td><td rowspan=1 colspan=1>70.94%</td><td rowspan=1 colspan=1>65.52% (T = 125)</td><td rowspan=1 colspan=1>67.87% (T = 125)</td></tr><tr><td rowspan=1 colspan=5>ImageNet</td></tr><tr><td rowspan=1 colspan=1>ResNet34</td><td rowspan=1 colspan=1>70.2%</td><td rowspan=1 colspan=1>65.1%</td><td rowspan=1 colspan=1>56.87% (T = 250)</td><td rowspan=1 colspan=1>61.48% (T = 250)</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>69.35%</td><td rowspan=1 colspan=1>68.12%</td><td rowspan=1 colspan=1>62.73% (T= 250)</td><td rowspan=1 colspan=1>65.19% (T = 250)</td></tr></table>
+
+# 5 OVERALL TRAINING ALGORITHM
+
+Algorithm 1 defines the process to initialize the parameters (weights, thresholds) of SNN based on ANN-SNN conversion. Algorithm 2 and 3 show the mechanism of training the SNN with STDB. Algorithm 2 initializes the neuron parameters for every mini-batch, whereas Algorithm 3 performs the forward and backward propagation and computes the credit assignment. The threshold voltage for all neurons in a layer is same and is not altered in the training process. For each dropout layer we initialize a mask $( M )$ for every mini-batch of inputs. The function of dropout is to randomly drop a certain number of inputs in order to avoid overfitting. In case of SNN, inputs are represented as a spike train and we want to keep the dropout units same for the entire duration of the input. Thus, a random mask $( M )$ is initialized (Algorithm 2) for every mini-batch and the input is element-wise multiplied with the mask to generate the output of the dropout layer (Lee et al., 2019). The Poisson generator function outputs a Poisson spike train with rate proportional to the pixel value in the input. A random number is generated at every time step for each pixel in the input image. The random number is compared with the normalized pixel value and if the random number is less than the pixel value an output spike is generated. This results in a Poisson spike train with rate equivalent to the pixel value if averaged over a long time. The weighted sum of the input is accumulated in the membrane potential of the first convolution layer. The STDB function compares the membrane potential and the threshold of that layer to generate an output spike. The neurons that output a spike their corresponding entry in $S$ is updated with current time step (t). The last spike time is initialized with a large negative number (Algorithm 2) to denote that at the beginning the last spike happened at negative infinity time. This is repeated for all layers until the last layer. For last layer the inputs are accumulated over all time steps and passed through a softmax layer to compute the multi-class probability. The cross-entropy loss function is defined on the output of the softmax and the weights are updated by performing the temporal and spatial credit assignment according to the STDB rule.
+
+# 6 EXPERIMENTS
+
+We tested the proposed training mechanism on image classification tasks from CIFAR (Krizhevsky et al., 2009) and ImageNet (Deng et al., 2009) datasets. The results are summarized in Table 1.
+
+![](images/e3e63b533127c274de9937dff4bafa08dd1a34b21cf2cf9cdff0fbbaa024595c.jpg)  
+Figure 3: Average number of spikes for each layer in a VGG16 architecture for purely converted SNN and SNN trained with hybrid technique. The converted SNN and SNN trained with hybrid technique achieve an accuracy of $8 9 . 2 0 \%$ and $9 1 . 8 7 \%$ , respectively, for the randomly selected 1500 samples from the test set. Both the networks were inferred for 100 time steps and $\mathbf { \epsilon } \cdot \mathbf { \gamma } _ { \mathbf { V } } \mathbf { \epsilon } )$ represents the threshold voltage for each layer obtained during the conversion process (Algorithm 1).
+
+CIFAR10: The dataset consists of labeled 60, 000 images of 10 categories divided into training (50, 000) and testing (10, 000) set. The images are of size $3 2 \times 3 2$ with RGB channels.
+
+CIFAR100: The dataset is similar to CIFAR10 except that it has 100 categories.
+
+ImageNet: The dataset comprises of labeled high-resolution 1.2 million training images and 50, 000 validation images with 1000 categories.
+
+# 7 ENERGY-DELAY PRODUCT ANALYSIS OF SNNS
+
+A single spike in an SNN consumes a constant amount of energy (Cao et al., 2015). The first order analysis of energy-delay product of an SNN is dependent on the number of spikes and the total number of time steps. Fig. 3 shows the average number of spikes in each layer when evaluated for 1500 samples from CIFAR10 testset for VGG16 architecture. The average is computed by summing all the spikes in a layer over 100 time steps and dividing by the number of neurons in that layer. For example, the average number of spikes in the $1 0 ^ { t h }$ layer is 5.8 for both the networks, which implies that over a 100 time step period each neuron in that layer spikes 5.8 times on average over all input samples. Higher spiking activity corresponds to lower energy-efficiency. The average number of spikes is compared for a converted SNN and SNN trained with conversion-and-STDB. The SNN trained with conversion-and-STDB has $1 . 5 \times$ less number of average spikes over all layers under iso conditions (time steps, threshold voltages, inputs, etc.) and achieves higher accuracy compared to the converted SNN. The converted SNNs when simulated for larger time steps further degrade the energy-delay product with minimal increase in accuracy (Sengupta et al., 2019).
+
+# 8 RELATED WORK
+
+Bohte et al. (2000) proposed a method to directly train on SNN by keeping track of the membrane potential of spiking neurons only at spike times and backpropagating the error at spike times based on only the membrane potential. This method is not suitable for networks with sparse activity due to the ‘dead neuron’ problem: no learning happens when the neurons do not spike. In our work, we need one spike for the learning to start but gradient contribution continues in later time steps as shown in Fig. 1. Zenke & Ganguli (2018) derived a surrogate gradient based method on the membrane potential of a spiking neuron at a single time step only. The error was backpropagated at only one time step and only the input at that time step contributed to the gradient. This method neglects the effect of earlier spike inputs. In our approach, the error is backpropagated for every time step and the weight update is performed on the gradients summed over all time steps. Shrestha & Orchard (2018) proposed a gradient function similar to the one proposed in this work. They used the difference between the membrane potential and the threshold to compute the gradient compared to the difference in spike timing used in this work. The membrane potential is a continuous value whereas the spike time is an integer value bounded by the number of time steps. Therefore, gradients that depend on spike time can be pre-computed and stored in a look-up table for faster computation. They evaluated their approach on shallow architectures with two convolution layer for MNIST dataset. In this work, we trained deep SNNs with multiple stacked layers for complex calssification tasks. Wu et al. (2018) performed backpropagation through time on SNN with a surrogate gradient defined on the membrane potential. The surrogate gradient was defined as piece-wise linear or exponential function of the membrane potential. The other surrogate gradients proposed in the literature are all computed on the membrane potential (Neftci et al., 2019). Lee et al. (2019) approximated the neuron output as continuous low-pass filtered spike train. They used this approximated continuous value to perform backpropagation. Most of the works in the literature on direct training of SNN or conversion based methods have been evaluated on shallow architectures for simple classification problems. In Table 2 we compare our model with the models that reported accuracy on CIFAR10 and ImageNet dataset. Wu et al. (2019) achieved convergence in 12 time steps by using a dedicated encoding layer to capture the input precision. It is beyond the scope of this work to compute the hardware and energy implications of such encoding layer. Our model performs better than all other models at far fewer number of time steps.
+
+Table 2: Comparion of our work with other SNN models on CIFAR10 and ImageNet datasets   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>TrainingMethod</td><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1> Accuracy</td><td rowspan=1 colspan=1>Time-steps</td></tr><tr><td rowspan=1 colspan=1>Hunsberger&amp;Eliasmith(2015)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>2Conv,2Linear</td><td rowspan=1 colspan=1>82.95%</td><td rowspan=1 colspan=1>6000</td></tr><tr><td rowspan=1 colspan=1>Caoetal.(2015)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>3Conv,2Linear</td><td rowspan=1 colspan=1>77.43%</td><td rowspan=1 colspan=1>400</td></tr><tr><td rowspan=1 colspan=1> Senguptaet al. (2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>91.55%</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>Lee etal.(2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>Spiking BP</td><td rowspan=1 colspan=1>VGG9</td><td rowspan=1 colspan=1>90.45%</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Wu et al.(2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1> SurrogateGradient</td><td rowspan=1 colspan=1>5Conv,2Linear</td><td rowspan=1 colspan=1>90.53%</td><td rowspan=1 colspan=1>12</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>HybridTraining</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>91.13%92.02%</td><td rowspan=1 colspan=1>100200</td></tr><tr><td rowspan=1 colspan=1> Senguptaet al. (2019)</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>69.96%</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>HybridTraining</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>65.19%</td><td rowspan=1 colspan=1>250</td></tr></table>
+
+# 9 CONCLUSIONS
+
+The direct training of SNN with backpropagation is computationally expensive and slow, whereas ANN-SNN conversion suffers from high latency. To address this issue we proposed a hybrid training technique for deep SNNs. We took an SNN converted from ANN and used its weights and thresholds as initialization for spike-based backpropagation of SNN. We then performed spike-based backpropagation on this initialized network to obtain an SNN that can perform with fewer number of time steps. The number of epochs required to train SNN was also reduced by having a good initial starting point. The resultant trained SNN had higher accuracy and lower number of spikes/inference compared to purely converted SNNs at reduced number of time steps. The backpropagation through time was performed with surrogate gradient defined using neuron’s spike time that captured the temporal information and helped in reducing the number of time steps. We tested our algorithm on CIFAR and ImageNet datasets and achieved state-of-the-art performance with fewer number of time steps.
+
+# ACKNOWLEDGMENTS
+
+This work was supported in part by the National Science Foundation, in part by Vannevar Bush Faculty Fellowship, and in part by C-BRIC, one of six centers in JUMP, a Semiconductor Research Corporation (SRC) program sponsored by DARPA.
+
+# REFERENCES
+
+Guillaume Bellec, Darjan Salaj, Anand Subramoney, Robert Legenstein, and Wolfgang Maass. Long short-term memory and learning-to-learn in networks of spiking neurons. In Advances in Neural Information Processing Systems, pp. 787–797, 2018.
+
+Sander M Bohte, Joost N Kok, and Johannes A La Poutre. Spikeprop: backpropagation for networks ´ of spiking neurons. In ESANN, pp. 419–424, 2000.
+
+Y-Lan Boureau, Jean Ponce, and Yann LeCun. A theoretical analysis of feature pooling in visual recognition. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 111–118, 2010.
+
+Yongqiang Cao, Yang Chen, and Deepak Khosla. Spiking deep convolutional neural networks for energy-efficient object recognition. International Journal of Computer Vision, 113(1):54–66, 2015.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Peter U Diehl, Daniel Neil, Jonathan Binas, Matthew Cook, Shih-Chii Liu, and Michael Pfeiffer. Fast-classifying, high-accuracy spiking deep networks through weight and threshold balancing. In 2015 International Joint Conference on Neural Networks (IJCNN), pp. 1–8. IEEE, 2015.
+
+Peter U Diehl, Guido Zarrella, Andrew Cassidy, Bruno U Pedroni, and Emre Neftci. Conversion of artificial recurrent neural networks to spiking neural networks for low-power neuromorphic hardware. In 2016 IEEE International Conference on Rebooting Computing (ICRC), pp. 1–8. IEEE, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Dongsung Huh and Terrence J Sejnowski. Gradient descent for spiking neural networks. In Advances in Neural Information Processing Systems, pp. 1433–1443, 2018.
+
+Eric Hunsberger and Chris Eliasmith. Spiking deep networks with lif neurons. arXiv preprint arXiv:1510.08829, 2015.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Chankyu Lee, Syed Shakib Sarwar, and Kaushik Roy. Enabling spike-based backpropagation in state-of-the-art deep neural network architectures. arXiv preprint arXiv:1903.06379, 2019.
+
+Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks. arXiv preprint arXiv:1901.09948, 2019.
+
+Abhronil Sengupta, Yuting Ye, Robert Wang, Chiao Liu, and Kaushik Roy. Going deeper in spiking neural networks: $\mathrm { V g g }$ and residual architectures. Frontiers in neuroscience, 13, 2019.
+
+Sumit Bam Shrestha and Garrick Orchard. Slayer: Spike layer error reassignment in time. In Advances in Neural Information Processing Systems, pp. 1412–1421, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+Sen Song, Kenneth D Miller, and Larry F Abbott. Competitive hebbian learning through spike-timing-dependent synaptic plasticity. Nature neuroscience, 3(9):919, 2000.   
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.   
+Paul J Werbos et al. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.   
+Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in neuroscience, 12, 2018.   
+Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, Yuan Xie, and Luping Shi. Direct training for spiking neural networks: Faster, larger, better. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 1311–1318, 2019.   
+Friedemann Zenke and Surya Ganguli. Superspike: Supervised learning in multilayer spiking neural networks. Neural computation, 30(6):1514–1541, 2018.
+
+# A COMPARISONS WITH OTHER SURROGATE GRADIENTS
+
+The transfer function of the spiking neuron is a step function and its derivative is zero everywhere except at the time of spike where it is not defined. In order to perform backpropagation with spiking neuron several approximations are proposed for the gradient function (Bellec et al., 2018; Zenke & Ganguli, 2018; Shrestha & Orchard, 2018; Wu et al., 2018). These approximations are either a linear or exponential function of $\mathrm { ~ ( ~ } u \mathrm { ~ \mathrm { ~ - ~ } ~ } V _ { t } \mathrm { ) }$ , where $u$ is the membrane potential and $V _ { t }$ the threshold voltage (Fig. 4). These approximations are referred as surrogate gradient or pseudo-derivative. In this work, we proposed an approximation that is computed using the spike timing of the neuron (Equation 11). We compare our proposed approximation with the following surrogate gradients:
+
+![](images/cd48833ffbcb4acb67d4884150d62d285617702c65c61e577bbdc212ea2dfd23.jpg)  
+Figure 4: Linear and Exponential approximation of the gradient of the spiking neuron (step function).
+
+$$
+\frac { \partial o } { \partial u } = \alpha \ : m a x \{ 0 , 1 - | u - V _ { t } | \}
+$$
+
+$$
+\frac { \partial o } { \partial u } = \alpha e ^ { - \beta \left| u - V _ { t } \right| }
+$$
+
+where $o$ is the binary output of the neuron, $u$ is the membrane potential, $V _ { t }$ is the threshold potential, $\alpha$ and $\beta$ are constants. Equation 13 and Equation 14 represent the linear and exponential approximation of the gradient, respectively. We employed these approximations in the hybrid training for a VGG9 network for CIFAR10 dataset. All the approximations (Equation 11, 13, and 14) produced similar results in terms of accuracy and number of epochs for convergence. This shows that the term $\Delta t$ (Equation 11) is a good replacement for $| u - V _ { t } |$ (Equation 14). The behaviour of $\Delta t$ and $| u - V _ { t } |$ is similar, i.e., it is small closer to the time of spike and increases as we move away from the spiking event. The advantage of using $\Delta t$ is that its domain is bounded by the total number of time steps (Equation 12). Hence, all possible values of gradients can be pre-computed and stored in a table for faster access during training. This is not possible for membrane potential because it is a real value computed based on the stochastic inputs and previous state of the neuron which is not known before hand. The exact benefit in energy from the pre-computation is dependent on the overall system architecture and evaluating it is beyond the scope of this paper.
+
+# B COMPARISONS OF SIMULATION TIME AND MEMORY REQUIREMENTS
+
+The simulation time and memory requirements for ANN and SNN are very different. SNN requires much more resources to iterate over multiple time steps and store the membrane potential for each neuron. Fig. 5 shows the training and inference time and memory requirements for ANN, SNN trained with backpropagation from scratch, and SNN trained with the proposed hybrid technique. The performance was evaluated for VGG16 architecture trained for CIFAR10 dataset. SNN trained from scratch and SNN trained with hybrid conversion-and-STDB are evaluated for 100 time steps. One epoch of ANN training (inference) takes 0.57 (0.05) minutes and 1.47 (1.15) GB of GPU memory. On the other hand, one epoch of SNN training (inference) takes 78 (11.39) minutes and 9.36 (1.37) GB of GPU memory for same hardware and mini-batch size. ANN and SNN trained from scratch reached convergence after 250 epochs. The hybrid technique requires 250 epochs of ANN training and 20 epochs of spike-based backpropagation. The hybrid training technique is one order of magnitude faster than training SNN from scratch. The memory requirement for hybrid technique is same as SNN as we need to perform fine-tuning with spike-based backpropagation.
+
+![](images/392c5b09ee728a2f6923f49603f3ba52dfef46b07e93158f58385264a0bbe80e.jpg)  
+Figure 5: Training and Inference time and memory for ANN, SNN trained with backpropagation from scratch, and SNN trained with hybrid technique. All values are normalized based on ANN values. The y-axis is in log scale. The performance was evaluated on one Nvidia GeForce RTX 2080 Ti TU102 GPU with 11 GB of memory. All the networks were trained for VGG16 architecture, CIFAR10 dataset, 100 time steps, and mini-batch size of 32. ANN and SNN require 250 epochs of training from scratch, hybrid conversion-and-STDB based training requires 250 epochs of ANN training followed by 20 epochs of spike-based backpropagation.

parse/train/B1xSperKvH/B1xSperKvH_content_list.json

@@ -0,0 +1,1238 @@
+[
+    {
+        "type": "text",
+        "text": "ENABLING DEEP SPIKING NEURAL NETWORKSWITH HYBRID CONVERSION AND SPIKE TIMINGDEPENDENT BACKPROPAGATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nitin Rathi1, Gopalakrishnan Srinivasan1, Priyadarshini Panda2 & Kaushik Roy1 ",
+        "bbox": [
+            184,
+            194,
+            754,
+            210
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1School of Electrical and Computer Engineering, Purdue University 2Department of Electrical Engineering, Yale University {rathi2, srinivg}@purdue.edu, priya.panda@yale.edu, kaushik@purdue.edu ",
+        "bbox": [
+            184,
+            212,
+            673,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            303,
+            544,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spiking Neural Networks (SNNs) operate with asynchronous discrete events (or spikes) which can potentially lead to higher energy-efficiency in neuromorphic hardware implementations. Many works have shown that an SNN for inference can be formed by copying the weights from a trained Artificial Neural Network (ANN) and setting the firing threshold for each layer as the maximum input received in that layer. These type of converted SNNs require a large number of time steps to achieve competitive accuracy which diminishes the energy savings. The number of time steps can be reduced by training SNNs with spike-based backpropagation from scratch, but that is computationally expensive and slow. To address these challenges, we present a computationally-efficient training technique for deep SNNs1. We propose a hybrid training methodology: 1) take a converted SNN and use its weights and thresholds as an initialization step for spike-based backpropagation, and 2) perform incremental spike-timing dependent backpropagation (STDB) on this carefully initialized network to obtain an SNN that converges within few epochs and requires fewer time steps for input processing. STDB is performed with a novel surrogate gradient function defined using neuron’s spike time. The weight update is proportional to the difference in spike timing between the current time step and the most recent time step the neuron generated an output spike. The SNNs trained with our hybrid conversion-and-STDB training perform at $1 0 \\times - 2 5 \\times$ fewer number of time steps and achieve similar accuracy compared to purely converted SNNs. The proposed training methodology converges in less than 20 epochs of spike-based backpropagation for most standard image classification datasets, thereby greatly reducing the training complexity compared to training SNNs from scratch. We perform experiments on CIFAR-10, CIFAR-100 and ImageNet datasets for both VGG and ResNet architectures. We achieve top-1 accuracy of $6 5 . 1 9 \\%$ for ImageNet dataset on SNN with 250 time steps, which is $1 0 \\times$ faster compared to converted SNNs with similar accuracy. ",
+        "bbox": [
+            232,
+            337,
+            764,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            336,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, Spiking Neural Networks (SNNs) have shown promise towards enabling low-power machine intelligence with event-driven neuromorphic hardware. Founded on bio-plausibility, the neurons in an SNN compute and communicate information through discrete binary events (or spikes) a significant shift from the standard artificial neural networks (ANNs), which process data in a real-valued (or analog) manner. The binary all-or-nothing spike-based communication combined with sparse temporal processing precisely make SNNs a low-power alternative to conventional ANNs. With all its appeal for power efficiency, training SNNs still remains a challenge. The discontinuous and non-differentiable nature of a spiking neuron (generally, modeled as leaky-integrate-and-fire (LIF), or integrate-and-fire (IF)) poses difficulty to conduct gradient descent based backpropagation. Practically, SNNs still lag behind ANNs, in terms of performance or accuracy, in traditional learning tasks. Consequently, there has been several works over the past few years that propose different learning algorithms or learning rules for implementing deep convolutional SNNs for complex visual recognition tasks (Wu et al., 2019; Hunsberger & Eliasmith, 2015; Cao et al., 2015). Of all the techniques, conversion from ANN-to-SNN (Diehl et al., 2016; 2015; Sengupta et al., 2019; Hunsberger & Eliasmith, 2015) has yielded state-of-the-art accuracies matching deep ANN performance for Imagenet dataset on complex architectures (such as, VGG (Simonyan & Zisserman, 2014) and ResNet (He et al., 2016) ). In conversion, we train an ANN with ReLU neurons using gradient descent and then convert the ANN to an SNN with IF neurons by using suitable threshold balancing (Sengupta et al., 2019). But, SNNs obtained through conversion incur large latency of 2000−2500 time steps (measured as total number of time steps required to process a given input image2). The term ‘time step’ defines an unit of time required to process a single input spike across all layers and represents the network latency. The large latency translates to higher energy consumption during inference, thereby, diminishing the efficiency improvements of SNNs over ANNs. To reduce the latency, spike-based backpropagation rules have been proposed that perform end-to-end gradient descent training on spike data. In spike-based backpropagation methods, the non-differentiability of the spiking neuron is handled by either approximating the spiking neuron model as continuous and differentiable (Huh & Sejnowski, 2018) or by defining a surrogate gradient as a continuous approximation of the real gradient (Wu et al., 2018; Bellec et al., 2018; Neftci et al., 2019). Spike-based SNN training reduces the overall latency by ${ \\sim } 1 0 \\times$ (for instance, $2 0 0 \\mathrm { ~ - ~ } 2 5 0$ time steps required to process an input (Lee et al., 2019)) but requires more training effort (in terms of total training iterations) than conversion approaches. A single feed-forward pass in ANN corresponds to multiple forward passes in SNN which is proportional to the number of time steps. In spike-based backpropagation, the backward pass requires the gradients to be integrated over the total number of time steps that increases the computation and memory complexity. The multiple-iteration training effort with exploding memory requirement (for backward pass computations) has limited the applicability of spike-based backpropagation methods to small datasets (like CIFAR10) on simple few-layered convolutional architectures. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a hybrid training technique which combines ANN-SNN conversion and spike-based backpropagation that reduces the overall latency as well as decreases the training effort for convergence. We use ANN-SNN conversion as an initialization step followed by spike-based backpropagation incremental training (that converges to optimal accuracy with few epochs due to the precursory initialization). Essentially, our hybrid approach of taking a converted SNN and incrementally training it using backpropagation yields improved energy-efficiency as well as higher accuracy than a model trained from scratch with only conversion or only spike-based backpropagation. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, this paper makes the following contributions: ",
+        "bbox": [
+            174,
+            631,
+            555,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a hybrid computationally-efficient training methodology for deep SNNs. We use the weights and firing thresholds of an SNN converted from an ANN as the initialization step for spike-based backpropagation. We then train this initialized network with spike-based backpropagation for few epochs to perform inference at a reduced latency or time steps. We propose a novel spike time-dependent backpropagation (STDB, a variant of standard spike-based backpropagation) that computes surrogate gradient using neuron’s spike time. The parameter update is triggered by the occurrence of spike and the gradient is computed based on the time difference between the current time step and the most recent time step the neuron generated an output spike. This is motivated from the Hebb’s principle which states that the plasticity of a synapse is dependent on the spiking activity of the neurons connected to the synapse. Our hybrid approach with the novel surrogate gradient descent allows training of large-scale SNNs without exploding memory required during spike-based backpropagation. We evaluate our hybrid approach on large SNNs (VGG, ResNet-like architectures) on ",
+        "bbox": [
+            214,
+            659,
+            825,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Imagenet, CIFAR datasets and show near iso-accuracy compared to similar ANNs and converted SNNs at lower compute cost and energy. ",
+        "bbox": [
+            232,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 SPIKE TIMING DEPENDENT BACKPROPAGATION (STDB) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            160,
+            678,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the spiking neuron model, derive the equations for the proposed surrogate gradient based learning, present the weight initialization method for SNN, discuss the constraints applied for ANN-SNN conversion, and summarize the overall training methodology. ",
+        "bbox": [
+            174,
+            196,
+            485,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEAKY INTEGRATE AND FIRE (LIF) NEURON MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            320,
+            410,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The neuron model defines the dynamics of the neuron’s internal state and the trigger for it to generate a spike. The differential equation ",
+        "bbox": [
+            173,
+            363,
+            483,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca868a77e61676a2fe3969838076cc4d33f04b2cff402211675f9aed2ce13dc2.jpg",
+        "text": "$$\n\\tau \\frac { d U } { d t } = - ( U - U _ { r e s t } ) + R I\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            419,
+            428,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c4a28ea13d64064dc648e47aca903dfa249118653d5d33be93a1c4056719f2e.jpg",
+        "image_caption": [
+            "Figure 1: Surrogate gradient of the spiking neuron activation function (Eq. 11). $\\alpha = 0 . 3 , \\beta = 0 . 0 1$ . The gradient is computed for each neuron and $\\Delta t$ defines the time difference between current simulation time and the last spike time of the neuron. For example, if a neuron spikes at $t _ { s } = 1 2$ its gradient will be maximum at $t = 1 2 ( \\Delta t = 0 )$ and gradually decrease for later time steps. If the same neuron spikes later at $t _ { s } = 2 4$ its previous spike history will be overwritten and the gradient computation for $t = 2 4$ onward will only consider the most recent spike. This avoids the overhead of storing all the spike history in memory. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            214,
+            821,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "is widely used to characterize the leaky-integrate-and-fire (LIF) neuron model where, $U$ is the internal state of the neuron referred as the membrane potential, $U _ { r e s t }$ is the resting potential, $R$ and $I$ are the input resistance and the current, respectively. The above equation is valid when the membrane potential is below the threshold value $( V )$ . The neuron geneartes an output spike when $U { \\geqslant } V$ ",
+        "bbox": [
+            174,
+            463,
+            483,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and $U$ is reduced to the reset potential. This representation is described in continuous domain and more suitable for biological simulations. We modify the equation to be evaluated in a discrete manner in the Pytorch framework ( $\\mathrm { W u }$ et al., 2018). The iterative model for a single post-neuron is described by ",
+        "bbox": [
+            174,
+            588,
+            826,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a764cd6bdfda7f3e162656f136297a22e529f81902dc5bf6fb8c23bd44c34af.jpg",
+        "text": "$$\nu _ { i } ^ { t } = \\lambda u _ { i } ^ { t - 1 } + \\sum _ { j } w _ { i j } o _ { j } ^ { t } - v o _ { i } ^ { t - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            652,
+            612,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3137496a990b78f4f053b333d9ab38f8db4554e8676046b5890d82b65ba96d46.jpg",
+        "text": "$$\no _ { i } ^ { t - 1 } = \\left\\{ { \\begin{array} { l l } { 1 , } & { { \\mathrm { i f ~ } } u _ { i } ^ { t - 1 } > v } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            713,
+            584,
+            748
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $u$ is the membrane potential, subscript $i$ and $j$ represent the post- and pre-neuron, respectively, superscript $t$ is the time step, $\\lambda$ is a constant $( < 1 )$ responsible for the leak in membrane potential, $w$ is the weight connecting the pre- and post-neuron, $o$ is the binary output spike, and $v$ is the firing threshold potential. The right hand side of Equation 2 has three terms: the first term calculates the leak in the membrane potential from the previous time step, the second term integrates the input from the previous layer and adds it to the membrane potential, and the third term which is outside the summation reduces the membrane potential by the threshold value if a spike is generated. This is known as soft reset as the membrane potential is lowered by $v$ compared to hard reset where the membrane potential is reduced to the reset value. Soft reset enables the spiking neuron to carry forward the excess potential above the firing threshold to the following time step, thereby minimizing information loss. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f9596c24c69f972dbb7dfacdd98897f442b2b53243f85c74e46dac6e9329812.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 1 ANN-SNN conversion: initialization of weights and threshold voltages Input: Trained ANN model (A), SNN model (N), Input (X) // Copy ann weights to snn</td></tr><tr><td>for l=1 to L do |Ni.W ← A.W end // Initialize threshold voltage to O V ←[0,·…·,0]L-1 for l=1 to L-1 do c↑0 for t=1 to T do</td></tr><tr><td>Ot ← PoissonGenerator(X) for k=1 to l do ifk&lt;l then // Forward (Algorithm 3) end</td></tr><tr><td>else // Pre-nonlinearity (A) A ← Nt(O-1) if max(A) &gt; v then v ←max(A) end end end</td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            488,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/22c871afd72e7ae17fe73eb2cf2297d3b354828a4e971daebf3388808fa59765.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2 Initialize the neuron parameters. Membrane potential (U),last spike time(S), dropout mask (M).The initialization is performed once for everymini-batch.</td></tr><tr><td>Input: Input(X), network model(N) b_size=X.b_size h=X.height w=X.width for l=1 to L do</td></tr><tr><td>if isintance(Ni,Conv) then Ut = zeros(b_size,Ni.out,h,w) St = ones(b_size,Ni.out,h,w) * (-1000) end elseif isintance(Nt,Linear) then Ut = zeros(b_size,Ni.out) St = ones(b_size,Ni.out) *(-1000)</td></tr><tr><td>end else if isintance(Ni,Dropout) then // Generate the dropout map that will be fixed for all time steps Mt = Ni(ones(Ut-1.shape)) end else ifisintance(Ni,AugPool) then //Reduce the width and height after average pooling layer h=h//kernel_size w=w//kernel_size end</td></tr></table>",
+        "bbox": [
+            513,
+            104,
+            823,
+            527
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 SPIKE TIMING DEPENDENT BACKPROPAGATION (STDB) LEARNING RULE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            728,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The neuron dynamics (Equation 2) show that the neuron’s state at a particular time step recurrently depends on its state in previous time steps. This introduces implicit recurrent connections in the network (Neftci et al., 2019). Therefore, the learning rule has to perform the temporal credit assignment along with the spatial credit assignment. Credit assignment refers to the process of assigning credit or blame to the network parameters according to their contribution to the loss function. Spatial credit assignment identifies structural network parameters (like weights), whereas temporal credit assignment determines which past network activities contributed to the loss function. Gradient-descent learning solves both credit assignment problem: spatial credit assignment is performed by distributing error spatially across all layers using the chain rule of derivatives, and temporal credit assignment is done by unrolling the network in time and performing backpropagation through time (BPTT) using the same chain rule of derivatives (Werbos et al., 1990). In BPTT, the network is unrolled for all time steps and the final output is computed as the sum of outputs from each time step. The loss function is defined on the summed output. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The dynamics of the neuron in the output layer is described by Equation (4), where the leak part is removed $\\lambda = 1$ ) and the neuron only integrates the input without firing. This eliminates the difficulty of defining the loss function on spike count (Lee et al., 2019). ",
+        "bbox": [
+            174,
+            768,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18b0132d3bf849f9819844e04bdf32195c80f6e2bd7ab05d4d6a2fbbc255d3cd.jpg",
+        "text": "$$\nu _ { i } ^ { t } = u _ { i } ^ { t - 1 } + \\sum _ { j } w _ { i j } o _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            825,
+            576,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The number of neurons in the output layer is the same as the number of categories in the classification task. The output of the network is passed through a softmax layer that outputs a probability distribution. The loss function is defined as the cross-entropy between the true output and the ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "network’s predicted distribution. ",
+        "bbox": [
+            173,
+            103,
+            387,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1903200c357aa7e29b818c4bcf23d950a97ad23b168705127aa6b073928e3db.jpg",
+        "text": "$$\n\\begin{array} { c } { L = - \\displaystyle \\sum _ { i } y _ { i } l o g ( p _ { i } ) } \\\\ { p _ { i } = \\displaystyle \\frac { e ^ { u _ { i } ^ { T } } } { \\sum _ { k = 1 } ^ { N } e ^ { u _ { k } ^ { T } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            116,
+            568,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$L$ is the loss function, $y$ the true output, $p$ the prediction, $T$ the total number of time steps, $u ^ { T }$ the accumulated membrane potential of the neuron in the output layer from all time steps, and $N$ the number of categories in the task. For deeper networks and large number of time steps the truncated version of the BPTT algorithm is used to avoid memory issues. In the truncated version the loss is computed at some time step $t ^ { \\prime }$ before $\\mathrm { T }$ based on the potential accumulated till $t ^ { \\prime }$ . The loss is backpropagated to all layers and the loss gradients are computed and stored. At this point, the history of the computational graph is cleaned to save memory. The subsequent computation of loss gradients at later time steps $( 2 t ^ { \\prime } , 3 t ^ { \\prime } , . . . T )$ are summed together with the gradient at $t ^ { \\prime }$ to get the final gradient. The optimizer updates the parameters at $T$ based on the sum of the gradients. Gradient descent learning has the objective of minimizing the loss function. This is achieved by backpropagating the error and updating the parameters opposite to the direction of the derivative. The derivative of the loss function w.r.t. to the membrane potential of the neuron in the final layer is described by, ",
+        "bbox": [
+            173,
+            204,
+            825,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e0f69991a1b9cb28836403a655a2c8823cd03fd64bd653c010dc54ee86ae493.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial u _ { i } ^ { T } } = p _ { i } - y _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            382,
+            552,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To compute the gradient at current time step, the membrane potential at last time step $( u _ { i } ^ { t - 1 }$ in Equation 4) is considered as an input quantity. Therefore, gradient descent updates the network parameters $W _ { i j }$ of the output layer as, ",
+        "bbox": [
+            176,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de2cb2c4e65328e8505e5c38a4758eb0509bbcf848a9b39c9d8dc7377d3d9488.jpg",
+        "text": "$$\nW _ { i j } = W _ { i j } - \\eta \\Delta W _ { i j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            478,
+            575,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7787e29d0e9212acded98702dae3e92f12e9328060a0e72acc22b4c5c84411b8.jpg",
+        "text": "$$\n\\Delta W _ { i j } = \\sum _ { t } { \\frac { \\partial L } { \\partial W _ { i j } ^ { t } } } = \\sum _ { t } { \\frac { \\partial L } { \\partial u _ { i } ^ { T } } } { \\frac { \\partial u _ { i } ^ { T } } { \\partial W _ { i j } ^ { t } } } = { \\frac { \\partial L } { \\partial u _ { i } ^ { T } } } \\sum _ { t } { \\frac { \\partial u _ { i } ^ { T } } { \\partial W _ { i j } ^ { t } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            501,
+            689,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta$ is the learning rate, and ${ W } _ { i j } ^ { t }$ represents the copy of the weight used for computation at time step $t$ . In the output layer the neurons do not generate a spike, and hence, the issue of non-differentiability is not encountered. The update of the hidden layer parameters is described by, ",
+        "bbox": [
+            174,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0183488251c9af27b9f2519e8eeb977ce9ad20b05f29372f1069b0f983b6adb2.jpg",
+        "text": "$$\n\\Delta W _ { i j } = \\sum _ { t } { \\frac { \\partial L } { \\partial W _ { i j } ^ { t } } } = \\sum _ { t } { \\frac { \\partial L } { \\partial o _ { i } ^ { t } } } { \\frac { \\partial o _ { i } ^ { t } } { \\partial u _ { i } ^ { t } } } { \\frac { \\partial u _ { i } ^ { t } } { \\partial W _ { i j } ^ { t } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            609,
+            640,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $o _ { i } ^ { t }$ is the thresholding function (Equation 3) whose derivative w.r.t to $u _ { i } ^ { t }$ is zero everywhere and not defined at the time of spike. The challenge of discontinuous spiking nonlinearity is resolved by introducing a surrogate gradient which is the continuous approximation of the real gradient. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a540262c31a21913d6a2ef06f28987c7dcfbc20258c80a289155326c3e2c878d.jpg",
+        "text": "$$\n\\frac { \\partial o _ { i } ^ { t } } { \\partial u _ { i } ^ { t } } = \\alpha e ^ { - \\beta \\Delta t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            704,
+            552,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ and $\\beta$ are constants, $\\Delta t$ is the time difference between the current time step $\\mathbf { \\rho } ( t )$ and the last time step the post-neuron generated a spike $( t _ { s } )$ . It is an integer value whose range is from zero to the total number of time steps $( T )$ . ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31e23731d15cc1e1cfb193f5417fd0d48cc95ec82e121feca8456d06d9963885.jpg",
+        "text": "$$\n\\Delta t = ( t - t _ { s } ) , 0 < \\Delta t < T , \\Delta t \\epsilon \\mathbb { Z }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            795,
+            627,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The values of $\\alpha$ and $\\beta$ are selected depending on the value of $T$ . If $T$ is large $\\beta$ is lowered to reduce the exponential decay so a spike can contribute towards gradients for later time steps. The value of $\\alpha$ is also reduced for large $T$ because the gradient can propagate through many time steps. The gradient is summed at each time step and thus a large $\\alpha$ may lead to exploding gradient. The surrogate gradient can be pre-computed for all values of $\\Delta t$ and stored in a look-up table for faster computation. The parameter updates are triggered by the spiking activity but the error gradients are still non-zero for time steps following the spike time. This enables the algorithm to avoid the ‘dead ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Training an SNN with surrogate gradient computed with spike timing. The network is composed of $L$ layers. The training proceeds with mini-batch size (batch size) ",
+        "bbox": [
+            173,
+            102,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: Mini-batch of input $( X )$ - target $( Y )$ pairs, network model $( N )$ , initial weights $( W )$ , threshold voltage $( V )$   \n$U , S , M = I$ nitializeNeuronP arameter $s ( X )$ [Algorithm 2]   \n// Forward propagation   \nfor $t { = } I$ to $T$ do $O _ { 0 } ^ { t } = P o i s s o n G e n e r a t o r ( X )$ for $l { = } l$ to L-1 do if isintanc $e ( N _ { l } , [ C o n v , L i n e a r ] )$ then // accumulate the output of previous layer in $U$ , soft reset when spike occurs $\\begin{array} { r } { U _ { l } ^ { t } = \\lambda U _ { l } ^ { t - 1 } + W _ { l } \\dot { O } _ { l - 1 } ^ { t } - V _ { l } * O _ { l } ^ { t - 1 } } \\end{array}$ ? // generate the output $( + 1 )$ if $U$ exceeds $V$ $\\hat { O _ { l } ^ { t } } = S T D B ( U _ { l } ^ { t } , V _ { l } , t )$ $/ /$ store the latest spike times for each neuron $S _ { l } ^ { t } [ O _ { l } ^ { t } = = 1 ] = t$ end else if isintance ${ \\mathrm { : } } ( N _ { l } , A v g P o o l )$ then $O _ { l } ^ { t } = N _ { l } ( O _ { l - 1 } ^ { t } )$ end else if isintance $( N _ { l } , D r o p o u t )$ then $O _ { l } ^ { t } = O _ { l - 1 } ^ { t } * M _ { l }$ end end $U _ { L } ^ { t } = \\lambda U _ { L } ^ { t - 1 } + W _ { L } O _ { L - 1 } ^ { t }$   \nend   \n// Backward Propagation   \nCompute $\\frac { \\partial L } { \\partial U _ { L } }$ from the cross-entropy loss function using BPTT   \nfor $t { = } T$ to $^ { l }$ do for $\\scriptstyle { l = L - I }$ to 1 do Compute $\\frac { \\partial L } { \\partial O _ { l } ^ { t } }$ based on if $N _ { l }$ is linear, conv, pooling, etc. $\\begin{array} { r } { \\frac { \\partial L } { \\partial U _ { l } ^ { t } } = \\frac { \\partial L } { \\partial O _ { l } ^ { t } } \\frac { \\partial O _ { l } ^ { t } } { \\partial U _ { l } ^ { t } } = \\frac { \\partial L } { \\partial O _ { l } ^ { t } } \\ast \\alpha e ^ { - \\beta S _ { l } ^ { t } } } \\end{array}$ end   \nend ",
+        "bbox": [
+            176,
+            133,
+            820,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "neuron’ problem, where no learning happens when there is no spike. Fig. 1 shows the activation gradient for different values of $\\Delta t$ , the gradient decreases exponentially for neurons that have not been active for a long time. In Hebbian models of biological learning, the parameter update is activity dependent. This is experimentally observed in spike-timing-dependent plasticity (STDP) learning rule which modulates the weights for pair of neurons that spike within a time window (Song et al., 2000). ",
+        "bbox": [
+            173,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 SNN WEIGHT INITIALIZATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            462,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A prevalent method of constructing SNNs for inference is ANN-SNN conversion (Diehl et al., 2015; Sengupta et al., 2019). Since the network is trained with analog activations it does not suffer from the non-differentiablity issue and can leverage the training techniques of ANNs. The conversion process has a major drawback: it suffers from long inference latency ( $\\mathrm { \\sim 2 5 0 0 }$ time steps) as mentioned in Section 1. As there is no provision to optimize the parameters after conversion based on spiking activity, the network can not leverage the temporal information of the spikes. In this work, we propose to use the conversion process as an initialization technique for STDB. The converted weights and thresholds serve as a good initialization for the optimizer and the STDB learning rule is applied for temporal and spatial credit assignment. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 explains the ANN-SNN conversion process. The threshold voltages in SNN needs to be adjusted based on the ANN weights. Sengupta et al. (2019) showed two ways to achieve this: weight-normalization and threshold-balancing. In weight-normalization the weights are scaled by a normalization factor and threshold is set to 1, whereas in threshold-balancing the weights are unchanged and the threshold is set to the normalization factor. Both have a similar effect and either can be used to set the threshold. We employ the threshold-balancing method and the normalization factor is calculated as the maximum output of the corresponding convolution/linear layer in SNN. The maximum is calculated over a mini-batch of input for all time steps. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are several constraints imposed on training the ANN for the conversion process (Sengupta et al., 2019; Diehl et al., 2015). The neurons are trained without the bias term because the bias term in SNN has an indirect effect on the threshold voltage which increases the difficulty of threshold balancing and the process becomes more prone to conversion loss. The absence of bias term eliminates the use of Batch Normalization (Ioffe & Szegedy, 2015) as a regularizer in ANN since it biases the input of each layer to have zero mean. As an alternative, Dropout (Srivastava et al., 2014) is used as a regularizer for both ANN and SNN training. The implementation of Dropout in SNN is further discussed in Section 5. The pooling operation is widely used in ANN to reduce the convolution map size. There are two popular variants: max pooling and average pooling (Boureau et al., 2010). Max (Average) pooling outputs the maximum (average) value in the kernel space of the neuron’s activations. In SNN, the activations are binary and performing max pooling will result in significant information loss for the next layer, so we adopt the average pooling for both ANN and SNN (Diehl et al., 2015). ",
+        "bbox": [
+            176,
+            222,
+            581,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            439,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/31821489c1dc4301bde516e227360d788e26a0deac85ccef825dbbbadc225416.jpg",
+        "image_caption": [
+            "Figure 2: Residual architecture for SNN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            596,
+            238,
+            825,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the changes made to the VGG (Simonyan & Zisserman, 2014) and residual architecture (He et al., 2016) for hybrid learning and discuss the process of threshold computation for both the architectures. ",
+        "bbox": [
+            174,
+            558,
+            581,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 VGG ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            635,
+            367,
+            648
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The threshold balancing is performed for all layers except the input and output layer in a VGG architecture. For every hidden convolution/linear layer the maximum input3 to the neuron is computed over all time steps and set as threshold for that layer. The threshold assignment is done sequentially as described in Algorithm 1. The threshold computation for all layers can not be performed in parallel (in one forward pass) because in the forward method (Algorithm 3) we need the threshold at each time step to decide if the neuron should spike or not. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESIDUAL ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            401,
+            781
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Residual architectures introduce shortcut connections between layers that are not next to each other. In order to minimize the ANN-SNN conversion loss various considerations were made by Sengupta et al. (2019). The original residual architecture proposed by He et al. (2016) uses an initial convolution layer with wide kernel $( 7 \\times 7$ , stride 2). For conversion, this is replaced by a pre-processing block consisting of a series of three convolution layer $( 3 \\times 3$ , stride 1) with dropout layer in between (Fig. 2). The threshold balancing mechanism is applied to only these three layers and the layers in the basic block have unity threshold. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d6960da6d2ab1ef250ec4c809150250b2409864fcbf88a1f373de46cc253a99.jpg",
+        "table_caption": [
+            "Table 1: Classification results (Top-1) for CIFAR10, CIFAR100 and ImageNet data sets. Column-1 shows the network architecture. Column-2 shows the ANN accuracy when trained under the constraints as described in Section 3. Column-3 shows the SNN accuracy for $T \\ : = \\ : 2 5 0 0$ when converted from a ANN with threshold balancing. Column-4 shows the performance of the same converted SNN with lower time steps and adjusted thresholds. Column-5 shows the performance after training the Column-4 network with STDB for less than 20 epochs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>ANN</td><td rowspan=1 colspan=1>ANN-SNNConversion(T = 2500)</td><td rowspan=1 colspan=1>ANN-SNNConversion (reduced time steps)</td><td rowspan=1 colspan=1>Hybrid Training(ANN-SNN Conversion+ STDB)</td></tr><tr><td rowspan=1 colspan=5>CIFAR10</td></tr><tr><td rowspan=1 colspan=1>VGG5</td><td rowspan=1 colspan=1>87.88%</td><td rowspan=1 colspan=1>87.64%</td><td rowspan=1 colspan=1>84.56% (T = 75)</td><td rowspan=1 colspan=1>86.91% (T = 75)</td></tr><tr><td rowspan=1 colspan=1>VGG9</td><td rowspan=1 colspan=1>91.45%</td><td rowspan=1 colspan=1>90.98%</td><td rowspan=1 colspan=1>87.31% (T = 100)</td><td rowspan=1 colspan=1>90.54% (T = 100)</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>92.81%</td><td rowspan=1 colspan=1>92.48%</td><td rowspan=1 colspan=1>90.2% (T = 100)</td><td rowspan=1 colspan=1>91.13% (T = 100)</td></tr><tr><td rowspan=1 colspan=1>ResNet8</td><td rowspan=1 colspan=1>91.35%</td><td rowspan=1 colspan=1>91.12%</td><td rowspan=1 colspan=1>89.5% (T = 200)</td><td rowspan=1 colspan=1>91.35% (T = 200)</td></tr><tr><td rowspan=1 colspan=1>ResNet20</td><td rowspan=1 colspan=1>93.15%</td><td rowspan=1 colspan=1>92.94%</td><td rowspan=1 colspan=1>91.12% (T = 250)</td><td rowspan=1 colspan=1>92.22% (T = 250)</td></tr><tr><td rowspan=1 colspan=5>CIFAR100</td></tr><tr><td rowspan=1 colspan=1>VGG11</td><td rowspan=1 colspan=1>71.21%</td><td rowspan=1 colspan=1>70.94%</td><td rowspan=1 colspan=1>65.52% (T = 125)</td><td rowspan=1 colspan=1>67.87% (T = 125)</td></tr><tr><td rowspan=1 colspan=5>ImageNet</td></tr><tr><td rowspan=1 colspan=1>ResNet34</td><td rowspan=1 colspan=1>70.2%</td><td rowspan=1 colspan=1>65.1%</td><td rowspan=1 colspan=1>56.87% (T = 250)</td><td rowspan=1 colspan=1>61.48% (T = 250)</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>69.35%</td><td rowspan=1 colspan=1>68.12%</td><td rowspan=1 colspan=1>62.73% (T= 250)</td><td rowspan=1 colspan=1>65.19% (T = 250)</td></tr></table>",
+        "bbox": [
+            173,
+            202,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 OVERALL TRAINING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            488,
+            510
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 defines the process to initialize the parameters (weights, thresholds) of SNN based on ANN-SNN conversion. Algorithm 2 and 3 show the mechanism of training the SNN with STDB. Algorithm 2 initializes the neuron parameters for every mini-batch, whereas Algorithm 3 performs the forward and backward propagation and computes the credit assignment. The threshold voltage for all neurons in a layer is same and is not altered in the training process. For each dropout layer we initialize a mask $( M )$ for every mini-batch of inputs. The function of dropout is to randomly drop a certain number of inputs in order to avoid overfitting. In case of SNN, inputs are represented as a spike train and we want to keep the dropout units same for the entire duration of the input. Thus, a random mask $( M )$ is initialized (Algorithm 2) for every mini-batch and the input is element-wise multiplied with the mask to generate the output of the dropout layer (Lee et al., 2019). The Poisson generator function outputs a Poisson spike train with rate proportional to the pixel value in the input. A random number is generated at every time step for each pixel in the input image. The random number is compared with the normalized pixel value and if the random number is less than the pixel value an output spike is generated. This results in a Poisson spike train with rate equivalent to the pixel value if averaged over a long time. The weighted sum of the input is accumulated in the membrane potential of the first convolution layer. The STDB function compares the membrane potential and the threshold of that layer to generate an output spike. The neurons that output a spike their corresponding entry in $S$ is updated with current time step (t). The last spike time is initialized with a large negative number (Algorithm 2) to denote that at the beginning the last spike happened at negative infinity time. This is repeated for all layers until the last layer. For last layer the inputs are accumulated over all time steps and passed through a softmax layer to compute the multi-class probability. The cross-entropy loss function is defined on the output of the softmax and the weights are updated by performing the temporal and spatial credit assignment according to the STDB rule. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            326,
+            880
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We tested the proposed training mechanism on image classification tasks from CIFAR (Krizhevsky et al., 2009) and ImageNet (Deng et al., 2009) datasets. The results are summarized in Table 1. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3e63b533127c274de9937dff4bafa08dd1a34b21cf2cf9cdff0fbbaa024595c.jpg",
+        "image_caption": [
+            "Figure 3: Average number of spikes for each layer in a VGG16 architecture for purely converted SNN and SNN trained with hybrid technique. The converted SNN and SNN trained with hybrid technique achieve an accuracy of $8 9 . 2 0 \\%$ and $9 1 . 8 7 \\%$ , respectively, for the randomly selected 1500 samples from the test set. Both the networks were inferred for 100 time steps and $\\mathbf { \\epsilon } \\cdot \\mathbf { \\gamma } _ { \\mathbf { V } } \\mathbf { \\epsilon } )$ represents the threshold voltage for each layer obtained during the conversion process (Algorithm 1). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            103,
+            723,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CIFAR10: The dataset consists of labeled 60, 000 images of 10 categories divided into training (50, 000) and testing (10, 000) set. The images are of size $3 2 \\times 3 2$ with RGB channels. ",
+        "bbox": [
+            173,
+            397,
+            821,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CIFAR100: The dataset is similar to CIFAR10 except that it has 100 categories. ",
+        "bbox": [
+            174,
+            433,
+            696,
+            448
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ImageNet: The dataset comprises of labeled high-resolution 1.2 million training images and 50, 000 validation images with 1000 categories. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 ENERGY-DELAY PRODUCT ANALYSIS OF SNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            602,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A single spike in an SNN consumes a constant amount of energy (Cao et al., 2015). The first order analysis of energy-delay product of an SNN is dependent on the number of spikes and the total number of time steps. Fig. 3 shows the average number of spikes in each layer when evaluated for 1500 samples from CIFAR10 testset for VGG16 architecture. The average is computed by summing all the spikes in a layer over 100 time steps and dividing by the number of neurons in that layer. For example, the average number of spikes in the $1 0 ^ { t h }$ layer is 5.8 for both the networks, which implies that over a 100 time step period each neuron in that layer spikes 5.8 times on average over all input samples. Higher spiking activity corresponds to lower energy-efficiency. The average number of spikes is compared for a converted SNN and SNN trained with conversion-and-STDB. The SNN trained with conversion-and-STDB has $1 . 5 \\times$ less number of average spikes over all layers under iso conditions (time steps, threshold voltages, inputs, etc.) and achieves higher accuracy compared to the converted SNN. The converted SNNs when simulated for larger time steps further degrade the energy-delay product with minimal increase in accuracy (Sengupta et al., 2019). ",
+        "bbox": [
+            173,
+            536,
+            825,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            738,
+            344,
+            755
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bohte et al. (2000) proposed a method to directly train on SNN by keeping track of the membrane potential of spiking neurons only at spike times and backpropagating the error at spike times based on only the membrane potential. This method is not suitable for networks with sparse activity due to the ‘dead neuron’ problem: no learning happens when the neurons do not spike. In our work, we need one spike for the learning to start but gradient contribution continues in later time steps as shown in Fig. 1. Zenke & Ganguli (2018) derived a surrogate gradient based method on the membrane potential of a spiking neuron at a single time step only. The error was backpropagated at only one time step and only the input at that time step contributed to the gradient. This method neglects the effect of earlier spike inputs. In our approach, the error is backpropagated for every time step and the weight update is performed on the gradients summed over all time steps. Shrestha & Orchard (2018) proposed a gradient function similar to the one proposed in this work. They used the difference between the membrane potential and the threshold to compute the gradient compared to the difference in spike timing used in this work. The membrane potential is a continuous value whereas the spike time is an integer value bounded by the number of time steps. Therefore, gradients that depend on spike time can be pre-computed and stored in a look-up table for faster computation. They evaluated their approach on shallow architectures with two convolution layer for MNIST dataset. In this work, we trained deep SNNs with multiple stacked layers for complex calssification tasks. Wu et al. (2018) performed backpropagation through time on SNN with a surrogate gradient defined on the membrane potential. The surrogate gradient was defined as piece-wise linear or exponential function of the membrane potential. The other surrogate gradients proposed in the literature are all computed on the membrane potential (Neftci et al., 2019). Lee et al. (2019) approximated the neuron output as continuous low-pass filtered spike train. They used this approximated continuous value to perform backpropagation. Most of the works in the literature on direct training of SNN or conversion based methods have been evaluated on shallow architectures for simple classification problems. In Table 2 we compare our model with the models that reported accuracy on CIFAR10 and ImageNet dataset. Wu et al. (2019) achieved convergence in 12 time steps by using a dedicated encoding layer to capture the input precision. It is beyond the scope of this work to compute the hardware and energy implications of such encoding layer. Our model performs better than all other models at far fewer number of time steps. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/25a870a4d8b8ed3c0cd21eb06d167b377cafd5111c85072ac6fcbad72f6f1376.jpg",
+        "table_caption": [
+            "Table 2: Comparion of our work with other SNN models on CIFAR10 and ImageNet datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>TrainingMethod</td><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1> Accuracy</td><td rowspan=1 colspan=1>Time-steps</td></tr><tr><td rowspan=1 colspan=1>Hunsberger&amp;Eliasmith(2015)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>2Conv,2Linear</td><td rowspan=1 colspan=1>82.95%</td><td rowspan=1 colspan=1>6000</td></tr><tr><td rowspan=1 colspan=1>Caoetal.(2015)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>3Conv,2Linear</td><td rowspan=1 colspan=1>77.43%</td><td rowspan=1 colspan=1>400</td></tr><tr><td rowspan=1 colspan=1> Senguptaet al. (2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>91.55%</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>Lee etal.(2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>Spiking BP</td><td rowspan=1 colspan=1>VGG9</td><td rowspan=1 colspan=1>90.45%</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Wu et al.(2019)</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1> SurrogateGradient</td><td rowspan=1 colspan=1>5Conv,2Linear</td><td rowspan=1 colspan=1>90.53%</td><td rowspan=1 colspan=1>12</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>HybridTraining</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>91.13%92.02%</td><td rowspan=1 colspan=1>100200</td></tr><tr><td rowspan=1 colspan=1> Senguptaet al. (2019)</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>ANN-SNNConversion</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>69.96%</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>HybridTraining</td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>65.19%</td><td rowspan=1 colspan=1>250</td></tr></table>",
+        "bbox": [
+            196,
+            127,
+            799,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            455,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "9 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            328,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The direct training of SNN with backpropagation is computationally expensive and slow, whereas ANN-SNN conversion suffers from high latency. To address this issue we proposed a hybrid training technique for deep SNNs. We took an SNN converted from ANN and used its weights and thresholds as initialization for spike-based backpropagation of SNN. We then performed spike-based backpropagation on this initialized network to obtain an SNN that can perform with fewer number of time steps. The number of epochs required to train SNN was also reduced by having a good initial starting point. The resultant trained SNN had higher accuracy and lower number of spikes/inference compared to purely converted SNNs at reduced number of time steps. The backpropagation through time was performed with surrogate gradient defined using neuron’s spike time that captured the temporal information and helped in reducing the number of time steps. We tested our algorithm on CIFAR and ImageNet datasets and achieved state-of-the-art performance with fewer number of time steps. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by the National Science Foundation, in part by Vannevar Bush Faculty Fellowship, and in part by C-BRIC, one of six centers in JUMP, a Semiconductor Research Corporation (SRC) program sponsored by DARPA. ",
+        "bbox": [
+            176,
+            127,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            191,
+            287,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Bellec, Darjan Salaj, Anand Subramoney, Robert Legenstein, and Wolfgang Maass. Long short-term memory and learning-to-learn in networks of spiking neurons. In Advances in Neural Information Processing Systems, pp. 787–797, 2018. ",
+        "bbox": [
+            176,
+            215,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sander M Bohte, Joost N Kok, and Johannes A La Poutre. Spikeprop: backpropagation for networks ´ of spiking neurons. In ESANN, pp. 419–424, 2000. ",
+        "bbox": [
+            173,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y-Lan Boureau, Jean Ponce, and Yann LeCun. A theoretical analysis of feature pooling in visual recognition. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 111–118, 2010. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yongqiang Cao, Yang Chen, and Deepak Khosla. Spiking deep convolutional neural networks for energy-efficient object recognition. International Journal of Computer Vision, 113(1):54–66, 2015. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            171,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter U Diehl, Daniel Neil, Jonathan Binas, Matthew Cook, Shih-Chii Liu, and Michael Pfeiffer. Fast-classifying, high-accuracy spiking deep networks through weight and threshold balancing. In 2015 International Joint Conference on Neural Networks (IJCNN), pp. 1–8. IEEE, 2015. ",
+        "bbox": [
+            174,
+            450,
+            821,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter U Diehl, Guido Zarrella, Andrew Cassidy, Bruno U Pedroni, and Emre Neftci. Conversion of artificial recurrent neural networks to spiking neural networks for low-power neuromorphic hardware. In 2016 IEEE International Conference on Rebooting Computing (ICRC), pp. 1–8. IEEE, 2016. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dongsung Huh and Terrence J Sejnowski. Gradient descent for spiking neural networks. In Advances in Neural Information Processing Systems, pp. 1433–1443, 2018. ",
+        "bbox": [
+            171,
+            622,
+            823,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Hunsberger and Chris Eliasmith. Spiking deep networks with lif neurons. arXiv preprint arXiv:1510.08829, 2015. ",
+        "bbox": [
+            174,
+            661,
+            821,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            171,
+            739,
+            821,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chankyu Lee, Syed Shakib Sarwar, and Kaushik Roy. Enabling spike-based backpropagation in state-of-the-art deep neural network architectures. arXiv preprint arXiv:1903.06379, 2019. ",
+        "bbox": [
+            173,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks. arXiv preprint arXiv:1901.09948, 2019. ",
+        "bbox": [
+            169,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhronil Sengupta, Yuting Ye, Robert Wang, Chiao Liu, and Kaushik Roy. Going deeper in spiking neural networks: $\\mathrm { V g g }$ and residual architectures. Frontiers in neuroscience, 13, 2019. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sumit Bam Shrestha and Garrick Orchard. Slayer: Spike layer error reassignment in time. In Advances in Neural Information Processing Systems, pp. 1412–1421, 2018. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \nSen Song, Kenneth D Miller, and Larry F Abbott. Competitive hebbian learning through spike-timing-dependent synaptic plasticity. Nature neuroscience, 3(9):919, 2000.   \nNitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.   \nPaul J Werbos et al. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.   \nYujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in neuroscience, 12, 2018.   \nYujie Wu, Lei Deng, Guoqi Li, Jun Zhu, Yuan Xie, and Luping Shi. Direct training for spiking neural networks: Faster, larger, better. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 1311–1318, 2019.   \nFriedemann Zenke and Surya Ganguli. Superspike: Supervised learning in multilayer spiking neural networks. Neural computation, 30(6):1514–1541, 2018. ",
+        "bbox": [
+            171,
+            103,
+            828,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A COMPARISONS WITH OTHER SURROGATE GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            656,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The transfer function of the spiking neuron is a step function and its derivative is zero everywhere except at the time of spike where it is not defined. In order to perform backpropagation with spiking neuron several approximations are proposed for the gradient function (Bellec et al., 2018; Zenke & Ganguli, 2018; Shrestha & Orchard, 2018; Wu et al., 2018). These approximations are either a linear or exponential function of $\\mathrm { ~ ( ~ } u \\mathrm { ~ \\mathrm { ~ - ~ } ~ } V _ { t } \\mathrm { ) }$ , where $u$ is the membrane potential and $V _ { t }$ the threshold voltage (Fig. 4). These approximations are referred as surrogate gradient or pseudo-derivative. In this work, we proposed an approximation that is computed using the spike timing of the neuron (Equation 11). We compare our proposed approximation with the following surrogate gradients: ",
+        "bbox": [
+            174,
+            133,
+            483,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            369,
+            529,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd48833ffbcb4acb67d4884150d62d285617702c65c61e577bbdc212ea2dfd23.jpg",
+        "image_caption": [
+            "Figure 4: Linear and Exponential approximation of the gradient of the spiking neuron (step function). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            148,
+            820,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3ffa7db831cd988b1f4bbe805411a4c16c250967ce00caf69fdc7b114865c16.jpg",
+        "text": "$$\n\\frac { \\partial o } { \\partial u } = \\alpha \\ : m a x \\{ 0 , 1 - | u - V _ { t } | \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            388,
+            604,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e3cb13a7c82ebc99bad03106af2446876f13d041ebed34abb8d7cbfec9c4b23.jpg",
+        "text": "$$\n\\frac { \\partial o } { \\partial u } = \\alpha e ^ { - \\beta \\left| u - V _ { t } \\right| }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            425,
+            562,
+            455
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $o$ is the binary output of the neuron, $u$ is the membrane potential, $V _ { t }$ is the threshold potential, $\\alpha$ and $\\beta$ are constants. Equation 13 and Equation 14 represent the linear and exponential approximation of the gradient, respectively. We employed these approximations in the hybrid training for a VGG9 network for CIFAR10 dataset. All the approximations (Equation 11, 13, and 14) produced similar results in terms of accuracy and number of epochs for convergence. This shows that the term $\\Delta t$ (Equation 11) is a good replacement for $| u - V _ { t } |$ (Equation 14). The behaviour of $\\Delta t$ and $| u - V _ { t } |$ is similar, i.e., it is small closer to the time of spike and increases as we move away from the spiking event. The advantage of using $\\Delta t$ is that its domain is bounded by the total number of time steps (Equation 12). Hence, all possible values of gradients can be pre-computed and stored in a table for faster access during training. This is not possible for membrane potential because it is a real value computed based on the stochastic inputs and previous state of the neuron which is not known before hand. The exact benefit in energy from the pre-computation is dependent on the overall system architecture and evaluating it is beyond the scope of this paper. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            638
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B COMPARISONS OF SIMULATION TIME AND MEMORY REQUIREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            102,
+            785,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The simulation time and memory requirements for ANN and SNN are very different. SNN requires much more resources to iterate over multiple time steps and store the membrane potential for each neuron. Fig. 5 shows the training and inference time and memory requirements for ANN, SNN trained with backpropagation from scratch, and SNN trained with the proposed hybrid technique. The performance was evaluated for VGG16 architecture trained for CIFAR10 dataset. SNN trained from scratch and SNN trained with hybrid conversion-and-STDB are evaluated for 100 time steps. One epoch of ANN training (inference) takes 0.57 (0.05) minutes and 1.47 (1.15) GB of GPU memory. On the other hand, one epoch of SNN training (inference) takes 78 (11.39) minutes and 9.36 (1.37) GB of GPU memory for same hardware and mini-batch size. ANN and SNN trained from scratch reached convergence after 250 epochs. The hybrid technique requires 250 epochs of ANN training and 20 epochs of spike-based backpropagation. The hybrid training technique is one order of magnitude faster than training SNN from scratch. The memory requirement for hybrid technique is same as SNN as we need to perform fine-tuning with spike-based backpropagation. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            314
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/392c5b09ee728a2f6923f49603f3ba52dfef46b07e93158f58385264a0bbe80e.jpg",
+        "image_caption": [
+            "Figure 5: Training and Inference time and memory for ANN, SNN trained with backpropagation from scratch, and SNN trained with hybrid technique. All values are normalized based on ANN values. The y-axis is in log scale. The performance was evaluated on one Nvidia GeForce RTX 2080 Ti TU102 GPU with 11 GB of memory. All the networks were trained for VGG16 architecture, CIFAR10 dataset, 100 time steps, and mini-batch size of 32. ANN and SNN require 250 epochs of training from scratch, hybrid conversion-and-STDB based training requires 250 epochs of ANN training followed by 20 epochs of spike-based backpropagation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            329,
+            823,
+            521
+        ],
+        "page_idx": 13
+    }
+]

parse/train/S1zz2i0cY7/S1zz2i0cY7.md

@@ -0,0 +1,252 @@
+# INTEGER NETWORKS FOR DATA COMPRESSION WITH LATENT-VARIABLE MODELS
+
+Johannes Ballé, Nick Johnston & David Minnen Google Mountain View, CA 94043, USA {jballe,nickj,dminnen}@google.com
+
+# ABSTRACT
+
+We consider the problem of using variational latent-variable models for data compression. For such models to produce a compressed binary sequence, which is the universal data representation in a digital world, the latent representation needs to be subjected to entropy coding. Range coding as an entropy coding technique is optimal, but it can fail catastrophically if the computation of the prior differs even slightly between the sending and the receiving side. Unfortunately, this is a common scenario when floating point math is used and the sender and receiver operate on different hardware or software platforms, as numerical round-off is often platform dependent. We propose using integer networks as a universal solution to this problem, and demonstrate that they enable reliable cross-platform encoding and decoding of images using variational models.
+
+# 1 INTRODUCTION
+
+The task of information transmission in today’s world is largely divided into two separate endeavors: source coding, or the representation of data (such as audio or images) as sequences of bits, and channel coding, representing sequences of bits as analog signals on imperfect, physical channels such as radio waves (Cover and Thomas, 2006). This decoupling has substantial benefits, as the binary representations of arbitrary data can be seamlessly transmitted over arbitrary physical channels by only changing the underlying channel code, rather than having to design a new code for every possible combination of data source and physical channel. Hence, the universal representation of any compressed data today is the binary channel, a representation which consists of a variable number of binary symbols, each with probability $\textstyle { \frac { 1 } { 2 } }$ , and no noise (i.e. uncertainty).
+
+As a latent representation, the binary channel unfortunately is a severe restriction compared to the richness of latent representations defined by many variational latent-variable models in the literature (e.g., Kingma and Welling, 2014; Sønderby et al., 2016; van den Oord et al., 2017), and in particular models targeted at data compression (Theis et al., 2017; Ágústsson et al., 2017; Ballé et al., 2018). Variational latent-variable models such as VAEs (Kingma and Welling, 2014) consist of an encoder model distribution $e ( \pmb { y } \mid \pmb { x } )$ bringing the data $_ { \textbf { \em x } }$ into a latent representation $\textbf {  { y } }$ , and a decoder model distribution $d ( { \pmb x } \mid { \pmb y } )$ , which represents the data likelihood conditioned on the latents. Given an encoder $e$ , we observe the marginal distribution of latents $m ( \pmb { y } ) = \mathbb { E } _ { \pmb { x } } [ e ( \pmb { y } \mid \pmb { x } ) ]$ , where the expectation runs over the (unknown) data distribution. The prior $p ( \pmb { y } )$ is a variational estimate of the marginal (Alemi et al., 2018).
+
+By choosing the parametric forms of these distributions and the training objective appropriately, many such models succeed in representing relevant information in the data they are trained for quite compactly (i.e., with a small expected Kullback–Leibler (KL) divergence between the encoder and the prior, $\begin{array} { r } { \mathbb { E } _ { \pmb { x } } D _ { \mathrm { K L } } [ e \| p ] ) } \end{array}$ , and so may be called compressive in a sense. However, not all of them can be directly used for practical data compression, as the representation needs to be further converted into binary (entropy encoded). This conversion is typically performed by range coding, or arithmetic coding (Rissanen and Langdon, 1981). Range coding is asymptotically optimal: the length of the binary sequence quickly converges to the expected KL divergence in bits, for reasonably large sequences (such as, for one image). For this to hold, the following requirements must be satisfied:
+
+![](images/b6a6648bd111c33790c9a0a1e49addb8c95065b786817c864c1cea610843d505.jpg)  
+Figure 1: The same image, decoded with a model computing the prior using integer arithmetic (left), and the same model using floating point arithmetic (right). The image was decoded correctly, beginning in the top-left corner, until floating point round-off error caused a small discrepancy between the sender’s and the receiver’s copy of the prior, at which point the error propagated catastrophically.
+
+• The representation must be discrete-valued, i.e. have a finite number of states, and be noiseless – i.e. the conditional entropy of the encoder must be zero:
+
+$$
+H [ e ] = \mathbb { E } _ { \pmb { x } } \mathbb { E } _ { \pmb { y } \sim e } [ - \log e ( \pmb { y } \mid \pmb { x } ) ] = 0 .
+$$
+
+• All scalar elements of the representation $\textbf {  { y } }$ must be brought into a total ordering, and the prior needs to be written using the chain rule of calculus (as a product of conditionals), as the algorithm can only encode or decode one scalar random variable at a time.
+
+• Both sides of the binary channel (i.e. sender and receiver) must be able to evaluate the prior, and they must have identical instances of it.
+
+The latter point is crucial, as range coding is extremely sensitive to differences in $p$ between sender and receiver – so sensitive, in fact, that even small perturbations due to floating point round-off error can lead to catastrophic error propagation. Unfortunately, numerical round-off is highly platform dependent, and in typical data compression applications, sender and receiver may well employ different hardware or software platforms. Round-off error may even be non-deterministic on one and the same computer. Figure 1 illustrates a decoding failure in a model which computes $p$ using floating point math, caused by such computational non-determinism in sender vs. receiver. Recently, latent-variable models have been explored that employ artificial neural networks (ANNs) to compute hierarchical or autoregressive priors (Sønderby et al., 2016; van den Oord et al., 2017), including some of the best-performing learned image compression models (Ballé et al., 2018; Minnen et al., 2018; Klopp et al., 2018). Because ANNs are typically based on floating point math, these methods are vulnerable to catastrophic failures when deployed on heterogeneous platforms.
+
+To address this problem, and enable use of powerful learned variational models for real-world data compression, we propose to use integer arithmetic in these ANNs, as floating-point arithmetic cannot presently be made deterministic across arbitrary platforms. We formulate a type of quantized neural network we call integer networks, which are specifically targeted at generative and compression models, and at preventing computational non-determinism in computation of the prior. Because full determinism is a feature of many existing, widely used image and video compression methods, we also consider using integer networks end to end for computing the representation itself.
+
+# 2 INTEGER NEURAL NETWORKS
+
+ANNs are typically composite functions that alternate between linear and elementwise nonlinear operations. One linear operation followed by a nonlinearity is considered one layer of the network. To ensure that such a network can be implemented deterministically on a wide variety of hardware platforms, we restrict all the data types to be integral, and all operations to be implemented either with basic arithmetic or lookup tables. Because integer multiplications (including matrix multiplications or convolutions) increase the dynamic range of the output compared to their inputs, we introduce an additional step after each linear operator, where we divide each of its output by a learned parameter.
+
+![](images/c91a76ad0addf5cef94c1363679199123dda26f8a6a06cc57fa964c0de157f07.jpg)  
+Figure 2: Left: Example nonlinearity implementing a saturating rectifier for 4-bit unsigned integer outputs, given by $g _ { \mathrm { Q R e L U } } ( v ) = \mathrm { m a x } ( \mathrm { m i n } ( v , 1 5 ) , 0 )$ . This nonlinearity can be implemented deterministically either using a lookup table or simply using a clipping operation. The corresponding scaled cumulative of a generalized Gaussian with $\beta = 4$ used for computing gradients is plotted in cyan, and other choices of $\beta$ in gray. Right: Example nonlinearity approximating hyperbolic tangent for 4-bit signed integer outputs, given by $\begin{array} { r } { g _ { \mathrm { Q t a n h } } ( v ) = Q ( 7 \operatorname { t a n h } ( \frac { v } { 1 5 } ) ) } \end{array}$ . This nonlinearity can be implemented deterministically using a lookup table. The corresponding scaled hyperbolic tangent used for computing gradients is plotted in cyan.
+
+Concretely, we define the relationship between inputs $\textbf { \em u }$ and outputs $\pmb { w }$ of one layer as:
+
+$$
+\begin{array} { r } { \pmb { v } = ( \pmb { H } \pmb { u } + \pmb { b } ) \oslash \pmb { c } , } \\ { \pmb { w } = g ( \pmb { v } ) . } \end{array}
+$$
+
+In order, the inputs $\textbf { \em u }$ are subjected to a linear transform $\pmb { H }$ (a matrix multiplication, or a convolution); a bias vector $^ { b }$ is added; the result is divided elementwise by a vector $^ c$ , yielding an intermediate result vector $\textbf {  { v } }$ ; and finally, an elementwise nonlinearity $g$ is applied to $\pmb { v }$ .
+
+The activations $\textbf { \em w }$ and all intermediate results, as well as the parameters $H , b$ , and $^ c$ are all defined as integers. However, they may use differing number formats. For $\pmb { v }$ to be integral, we define $\oslash$ here to perform rounding division (equivalent to division followed by rounding to the nearest integer). In programming languages such as C, this can be implemented with integer operands $m , n$ as
+
+$$
+\begin{array} { r } { m \oslash n = Q ( \frac { m } { n } ) = ( m + n / / 2 ) \ / / n , } \end{array}
+$$
+
+where $Q$ rounds to the nearest integer and $/ /$ is floor division; here, the addition can be folded into the bias $^ { b }$ as an optimization. We constrain the linear filter coefficients $\pmb { H }$ and the bias vector $^ { b }$ to generally use signed integers, and the scaling vector $^ c$ to use unsigned integers. We implement the accumulators of the linear transform with larger bit width than the activations and filter coefficients, in order to reflect the potentially increased dynamic range of multiplicative operations. We assume here that the bias and scaling vectors, as well as the intermediate vector $\pmb { v }$ , have the same bit width as the accumulators.
+
+The elementwise nonlinearity $g$ must be saturating on both ends of its domain, because integers can only represent finite number ranges. In order to maximize utility of the dynamic range, we scale nonlinearities such that their range matches the bit width of $\pmb { w }$ , while their domain can be scaled somewhat arbitrarily. Depending on the range of the nonlinearity, the activations $\textbf { \em w }$ may use a signed or unsigned number format. For instance, a reasonable choice of number formats and nonlinearity would be:
+
+$$
+\begin{array} { c } { { H : 8 \mathrm { - b i t ~ s i g n e d ~ } } } \\ { { b , v : 3 2 \mathrm { - b i t ~ s i g n e d ~ ( s a m e ~ a s ~ a c c u m u l a t o r ) } } } \\ { { c : 3 2 \mathrm { - b i t ~ u n s i g n e d ~ } } } \\ { { w : 8 \mathrm { - b i t ~ u n s i g n e d ~ } } } \\ { { g _ { \mathrm { Q R e L U } } ( v ) = \mathrm { m a x } ( \mathrm { m i n } ( v , 2 5 5 ) , 0 ) } } \end{array}
+$$
+
+In this example, the nonlinearity can be implemented with a simple clipping operation. Refer to figure 2, left, for a visualization (for visualization purposes, the figure shows a smaller bit width).
+
+Another example is:
+
+$$
+\begin{array} { r } { g _ { \mathrm { Q t a n h } } ( v ) = Q \bigl ( 7 \operatorname { t a n h } ( \frac { v } { 1 5 } ) \bigr ) } \end{array}
+$$
+
+Here, the nonlinearity approximates the hyperbolic tangent, a widely used nonlinearity. It may be best implemented using a lookup table (see figure 2, right, for a visualization). We scale its range to fill the 4-bit signed integer number format of $\pmb { w }$ by multiplying its output with 7. The domain can be scaled somewhat arbitrarily, since $\pmb { v }$ has a larger bit width than $\pmb { w }$ . When it is chosen too small, $\pmb { w }$ may not utilize all integer values, leading to a large quantization error. When it is chosen too large, overflow may occur in $\pmb { v }$ , or the size of the lookup table may grow too large for practical purposes. Therefore, it is best to determine the input scaling based on the shape of the nonlinearity and the available dynamic range. Here, we simply chose the value of 15 “by eye”, so that the nonlinearity is reasonably well represented with the lookup table (i.e., we made sure that at least two or three input values are mapped to each output value, in order to preserve the approximate shape of the nonlinearity).
+
+# 3 TRAINING INTEGER NEURAL NETWORKS
+
+To effectively accumulate small gradient signals, we train the networks entirely using floating point computations, rounded to integers after every computational operation, while the backpropagation is done with full floating point precision. More concretely, we define the integer parameters $H , b ,$ and $^ c$ as functions of their floating point equivalents $H ^ { \prime } , b ^ { \prime }$ , and $c ^ { \prime }$ , respectively:
+
+$$
+\begin{array} { r l } & { \boldsymbol { H } = \left[ \begin{array} { c } { Q ( h _ { 1 } ^ { \prime } / s ( h _ { 1 } ^ { \prime } ) ) ) } \\ { \vdots } \\ { Q ( h _ { N } ^ { \prime } / s ( h _ { N } ^ { \prime } ) ) } \end{array} \right] , } \\ & { ~ b = Q \big ( 2 ^ { K } b ^ { \prime } \big ) , } \\ & { \boldsymbol { c } = Q \big ( 2 ^ { K } r ( \boldsymbol { c } ^ { \prime } ) \big ) . } \end{array}
+$$
+
+Here, we simply rescale each element of $\pmb { b } ^ { \prime }$ using a constant $K$ , which is the bit-width of the kernel $\pmb { H }$ (e.g. 8-bits in the QReLu networks), and round it to the nearest integer. The reparameterization mapping $r$ is borrowed from Ballé (2018):
+
+$$
+r ( c ^ { \prime } ) = \mathrm { m a x } \Big ( c ^ { \prime } , \sqrt { 1 + \epsilon ^ { 2 } } \Big ) ^ { 2 } - \epsilon ^ { 2 } .
+$$
+
+When $^ c$ is small, perturbations in $^ c$ can lead to excessively large fluctuations of the quotient (i.e., the input to the nonlinearity). This leads to instabilities in training. $r$ ensures that values of $^ c$ are always positive, while gracefully scaling down gradient magnitudes on $^ c$ near zero. Effectively, the step size on $^ c$ is multiplied with a factor that is approximately linear in $^ c$ (Ballé, 2018).
+
+Before rounding the linear filter coefficients in $\pmb { H } ^ { \prime } = [ h _ { 1 } ^ { \prime } , \ldots , h _ { N } ^ { \prime } ] ^ { \top }$ , we apply a special rescaling function $s$ to each of its filters $\mathbf { { } } h ^ { \prime }$ :
+
+$$
+s ( h ^ { \prime } ) = \mathrm { m a x } \Big ( ( - 2 ^ { K - 1 } ) ^ { - 1 } \operatorname* { m i n } _ { i } h _ { i } ^ { \prime } , ( 2 ^ { K - 1 } - 1 ) ^ { - 1 } \operatorname* { m a x } _ { i } h _ { i } ^ { \prime } , \epsilon \Big ) .
+$$
+
+$s$ rescales each filter such that at least one of its minimum and maximum coefficients hits one of the dynamic range bounds $( - 2 ^ { K - 1 }$ and $2 ^ { K - 1 } - 1 )$ ), while keeping zero at zero. This represents the finest possible quantization of the filter given its integer representation, and thus maximizes accuracy. To prevent division by zero, we ensure the divisor is larger than or equal to a small constant $\epsilon$ (for example, $\epsilon = 1 0 ^ { - \tilde { 2 } 0 }$ ).
+
+In order to backpropagate gradient signals into the parameters, one cannot simply take gradients of the loss function with respect to $H ^ { \prime }$ , $\pmb { b } ^ { \prime }$ , or $c ^ { \prime }$ , since the rounding function $Q$ has zero gradients almost everywhere, except for the half-integer positions where the gradient is positive infinity. A simple remedy is to replace the derivative of $Q$ with the identity function, since this is the smoothed gradient across all rounded values.
+
+Further, we treat the rescaling divisor $s$ as if it were a constant. That is, we compute the derivatives of the loss function with respect to $H ^ { \prime } , b ^ { \prime }$ , and $c ^ { \prime }$ as with the chain rule of calculus, but overriding:
+
+$$
+\frac { \partial h } { \partial h ^ { \prime } } : = \frac { 1 } { s ( h ^ { \prime } ) } , \qquad \frac { \partial b } { \partial b ^ { \prime } } : = 2 ^ { K } , \qquad \frac { \partial c } { \partial c ^ { \prime } } : = 2 ^ { K } r ^ { \prime } ( c ^ { \prime } ) ,
+$$
+
+where $r ^ { \prime }$ is the replacement gradient function for $r$ as proposed by Ballé (2018). After training is completed, we compute the integer parameters $\pmb { H }$ , $^ { b }$ and $^ c$ one more time, and from then on use them for evaluation. Note that further reparameterization of the kernels $H ^ { \prime }$ , such as Sadam (Ballé, 2018), or of the biases $\pmb { b } ^ { \prime }$ or scaling parameters $c ^ { \prime }$ , is possible by simply chaining reparameterizations.
+
+In addition to rounding the parameters, it is necessary to round the activations. To obtain gradients for the rounding division $\oslash$ , we simply substitute the gradient of floating point division. To estimate gradients for the rounded activation functions, we replace their gradient with the corresponding nonrounded activation function, plotted in cyan in figure 2. In the case of QReLU, the gradient of the clipping operation is a box function, which can lead to training getting stuck, since if activations consistently hit one of the bounds, no gradients are propagated back (this is sometimes called the “dead unit” problem). As a remedy, we replace the gradient instead with
+
+$$
+\frac { \partial g _ { \mathrm { Q R e L U } } ( v ) } { \partial v } : = \exp \Bigl ( - \alpha ^ { \beta } \Bigl | \frac { 2 v } { 2 ^ { L } - 1 } - 1 \Bigr | ^ { \beta } \Bigr ) ,
+$$
+
+where $\begin{array} { r } { \alpha = \frac { 1 } { \beta } \Gamma \left( \frac { 1 } { \beta } \right) } \end{array}$ , and $L$ is the bit width of $\textbf { \em w }$ . This function corresponds to a scaled generalized Gaussian probability density with shape parameter $\beta$ . In this context, we can think of $\beta$ as a temperature parameter that makes the function converge to the gradient of the clipping operation as $\beta$ goes to infinity. Although this setting permits an annealing schedule, we simply chose $\beta = 4$ and obtained good results. The integral of this function is plotted in figure 2 (left) in cyan, along with other choices of $\beta$ in gray.
+
+# 4 COMPUTING THE PRIOR WITH INTEGER NETWORKS
+
+Suppose our prior on the latent representation is $p ( \pmb { y } \mid z )$ , where $_ z$ summarizes other latent variables of the representation (it may be empty). To apply range coding, we need to impose a total ordering on the elements of $\textbf {  { y } }$ and write it as a chain of conditionals:
+
+$$
+p ( \pmb { y } \mid z ) = \prod _ { i } p ( y _ { i } \mid \pmb { y } _ { : i } , z ) ,
+$$
+
+where $\mathbf { \nabla } _ { \mathbf { { \boldsymbol { y } } } : i }$ denotes the vector of all elements of $\textbf {  { y } }$ preceding the ith. A common assumption is that $p$ is a known distribution, with parameters $\theta _ { i }$ computed by an $\operatorname { A N N } g$ :
+
+$$
+p ( \pmb { y } \mid z ) = \prod _ { i } p ( y _ { i } \mid \pmb { \theta } _ { i } ) \operatorname { w i t h } \pmb { \theta } _ { i } = g ( \pmb { y } _ { : i } , z )
+$$
+
+We simply propose here to compute $g$ deterministically using an integer network, discretizing the parameters $\pmb \theta$ to a reasonable accuracy. If $p ( y _ { i } \mid \pmb \theta _ { i } )$ itself cannot be computed deterministically, we can precompute all possible values and express it as a lookup table over $y _ { i }$ and $\theta _ { i }$ .
+
+As an example, consider the prior used in the image compression model proposed by Ballé et al. (2018), which is a modified Gaussian with scale parameters conditioned on another latent variable:
+
+$$
+p ( \pmb { y } \mid z ) = \prod _ { i } \left( \mathcal { N } ( 0 , \sigma _ { i } ^ { 2 } ) * \mathcal { U } ( - \textstyle \frac { 1 } { 2 } , \textstyle \frac { 1 } { 2 } ) \right) ( y _ { i } ) \mathrm { w i t h } \sigma = g ( z ) .
+$$
+
+We reformulate the scale parameters $\sigma$ as:
+
+$$
+\begin{array} { r } { \sigma _ { i } = \exp \Bigl ( \log \bigl ( \sigma _ { \operatorname* { m i n } } \bigr ) + \frac { \log \left( \sigma _ { \operatorname* { m a x } } \right) - \log \left( \sigma _ { \operatorname* { m i n } } \right) } { L - 1 } \theta _ { i } \Bigr ) , } \end{array}
+$$
+
+where $\pmb \theta = g ( z )$ is computed using an integer network. The last activation function in $g$ is chosen to have integer outputs of $L$ levels in the range $[ 0 , L - 1 ]$ . Constants $\sigma _ { \mathrm { m i n } }$ , $\sigma _ { \mathrm { m a x } }$ , and $L$ determine the discretized selection of scale parameters used in the model. The discretization is chosen to be logarithmic, as this choice minimizes $\mathbb { E } _ { \pmb { x } } D _ { \mathrm { K L } } [ e \Vert p ]$ for a given number of levels.
+
+During training, we can simply backpropagate through this reformulation, and through $g$ as described in the previous section. After training, we precompute all possible values of $p$ as a function of $y _ { i }$ and $\theta _ { i }$ and form a lookup table, while $g$ is implemented with integer arithmetic.
+
+For certain applications, it can be useful not only to be able to deploy a compression model across heterogenous platforms, but to go even further in also ensuring identical reconstructions of the data across platforms. To this end, it can be attractive to make the entire model robust to non-determinism. To use integer networks in the encoder or decoder, one can use the equivalent construction as in (13): define $e$ or $d$ as a known distribution, with parameters computed by an integer network. To allow the use of range coding, we’re especially interested in discrete-valued representations here, such as studied in van den Oord et al. (2017), Jang et al. (2017), Theis et al. (2017), Ágústsson et al. (2017), and Ballé et al. (2018), among others. These approaches typically employ biased gradient estimators.
+
+Jang et al. (2017) and Ágústsson et al. (2017) are concerned with producing gradients for categorical distributions and vector quantization (VQ), respectively. In both methods, the representation is found by evaluating an ANN followed by an arg max function, while useful gradients are obtained by substituting the arg max with a softmax function. Since arg max can be evaluated deterministically in a platform-independent way, and evaluating a softmax function with rounded inputs is feasible, integer networks can be combined with these models without additional modifications.
+
+Theis et al. (2017) and Ballé et al. (2018) differ mostly in the details of interaction between the encoder and the prior. These two approaches are particularly interesting for image compression, as they scale well: Image compression models are often trained with a rate–distortion objective with a Lagrange parameter $\lambda$ , equivalent to $\beta$ in the $\beta$ -VAE objective (Higgins et al., 2017; Alemi et al., 2018). Depending on the parameter, the latent representation carries vastly different amounts of information, and the optimal number of latent states in turn varies with that. While the number of latent states is a hyperparameter that needs to be chosen ahead of time in the categorical/VQ case, the latter two approaches can extend it as needed during training, because the latent states are organized along the real line. Further, for categorical distributions as well as VQ, the required dimensionality of the function computing the parameters grows linearly with the number of latent states due to their use of the arg max function. In the latter two models, the number of states can grow arbitrarily without increasing the dimensionality of $g$ .
+
+Both Theis et al. (2017) and Ballé et al. (2018) use deterministic encoder distributions (i.e. degenerating to delta distributions) during evaluation, but replace them with probabilistic versions for purposes of estimating $\mathbb { E } _ { \pmb { x } } D _ { \mathrm { K L } } [ e \Vert p ]$ during training. Theis et al. (2017) propose to use the following encoder distribution:
+
+$$
+\begin{array} { r } { e ( \pmb { y } \mid \pmb { x } ) = \mathcal { U } ( \pmb { y } \mid Q ( g ( \pmb { x } ) ) - \frac { 1 } { 2 } , Q ( g ( \pmb { x } ) ) + \frac { 1 } { 2 } ) , } \end{array}
+$$
+
+where $\mathcal { U }$ is the uniform distribution and $g$ is an ANN. They replace the gradient of the quantizer with the identity. During evaluation, $\pmb { y } = Q ( g ( \pmb { x } ) )$ is used as the representation. Ballé et al. (2018) use the following distribution during training:
+
+$$
+\begin{array} { r } { e ( \pmb { y } \mid \pmb { x } ) = \mathcal { U } ( \pmb { y } \mid g ( \pmb { x } ) - \frac { 1 } { 2 } , g ( \pmb { x } ) + \frac { 1 } { 2 } ) , } \end{array}
+$$
+
+which makes $\textbf {  { y } }$ shift-invariant. During evaluation, they determine the representation as ${ \textbf { 3 } } =$ $Q ( g ( \pmb { x } ) - \pmb { o } )$ , where $^ o$ is a sub-integer offset chosen such that the mode (or, if it cannot be estimated easily, the median) of the distribution is centered on one of the quantization bins.
+
+If $g$ is implemented with integer networks, the latter approach becomes equivalent to the former, because $g$ then inherently computes integer outputs, and this is effectively equivalent to the quantization in (16). However, we’ve found that training with this construction leads to instabilities, such that the prior distribution never converges to a stable set of parameters. The reason may be that with quantization in $e$ , the marginal $m ( \bar { \pmb { y } } ) = \mathbb { E } _ { \pmb { x } } e ( \pmb { y } \mid \pmb { x } )$ resembles a piecewise constant function, while the prior $p$ must be forced to be smooth, or $\mathbb { E } _ { \pmb { x } } D _ { \mathrm { K L } } [ e \Vert p ]$ would not yield any useful gradients. Because the prior is a variational approximation of the marginal, this means that the prior must be regularized (which we did not attempt here – we used the nonparametric density model described in Ballé et al. (2018)). On the other hand, when using (17) without quantization, the marginal is typically a smooth density, and the prior can approximate it closely without the need for regularization.
+
+As a remedy for the instabilities, we propose the following trick: We simply use (17) during training, but define the last layer of $g$ without a nonlinearity and with floating point division, such that the representation is
+
+$$
+\begin{array} { r } { e ( \pmb { y } \mid \pmb { x } ) = \mathcal { U } ( \pmb { y } \mid ( \pmb { H } \pmb { u } + \pmb { b } ) / c - \frac { 1 } { 2 } , ( \pmb { H } \pmb { u } + \pmb { b } ) / c + \frac { 1 } { 2 } ) , } \end{array}
+$$
+
+![](images/4169eee3870fc1b30ed28c0ec26e0fa7b41d213ef75cb24efacfc3951184acc1.jpg)  
+Figure 3: Rate–distortion performance of image compression models with integer priors (left and up is better). Left: performance of Ballé et al. (2018) model vs. the same model with an integer prior. The performance is identical, but the latter can be reliably deployed across different hardware platforms. Right: performance of Ballé (2018) ReLU model with 128 filters per layer vs. the same model, with integer transforms and QReLU activation functions and 128 or 256 filters per layer. The approximation capacity of integer networks is diminished vs. floating point networks, but doubling the number of filters per layer more than compensates for the loss.
+
+<table><tr><td rowspan=1 colspan=1>compressed ondecompressed on</td><td rowspan=1 colspan=1>CPU 1CPU 1</td><td rowspan=1 colspan=1>CPU 1GPU 1</td><td rowspan=1 colspan=1>CPU 1CPU 2</td><td rowspan=1 colspan=1>CPU 1GPU 2</td><td rowspan=1 colspan=1>GPU 1CPU 1</td><td rowspan=1 colspan=1>GPU 1GPU 1</td><td rowspan=1 colspan=1>GPU 1CPU 2</td><td rowspan=1 colspan=1>GPU 1GPU 2</td></tr><tr><td rowspan=1 colspan=9>Tecnick dataset:100 RGB i3 images of 1200 × 1200 pixels</td></tr><tr><td rowspan=1 colspan=1>Ballé et al. (2018)ditto, integer prior</td><td rowspan=1 colspan=1>0%0%</td><td rowspan=1 colspan=1>71%0%</td><td rowspan=1 colspan=1>54%0%</td><td rowspan=1 colspan=1>66%0%</td><td rowspan=1 colspan=1>63%0%</td><td rowspan=1 colspan=1>41%0%</td><td rowspan=1 colspan=1>59%0%</td><td rowspan=1 colspan=1>34%0%</td></tr><tr><td rowspan=1 colspan=9> CLIC dataset: 2021 RGB images of various pixel sizes</td></tr><tr><td rowspan=1 colspan=1>Ballé et al. (2018)ditto, integer prior</td><td rowspan=1 colspan=1>0%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>68%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>77%0%</td><td rowspan=1 colspan=1>52%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>54%0%</td></tr></table>
+
+CPU 1: Intel Xeon E5-1650 GPU 1: NVIDIA Titan X (Pascal) CPU 2: Intel Xeon E5-2690 GPU 2: NVIDIA Titan X (Maxwell)
+
+Table 1: Decompression failure rates due to floating point round-off error on Tecnick and CLIC image datasets. When compressing and decompressing on the same CPU platform (first column), the Ballé et al. (2018) model decompresses all images correctly. However, when compressing on a GPU or decompressing on a different platform, a large percentage of the images fail to be decoded correctly. Implementing the prior of the same model using integer networks ensures correct decompression across all tested platforms.
+
+during training, where $\textbf { \em u }$ is the input to the last layer and $/$ represents elementwise floating point division, and
+
+$$
+{ \pmb y } = Q \big ( ( { \pmb H } { \pmb u } + { \pmb b } ) / c - o \big )
+$$
+
+during evaluation. This can be rewritten strictly using integer arithmetic as:
+
+$$
+\pmb { y } = \left( \pmb { H } \pmb { u } + \pmb { b } - \pmb { Q } ( \pmb { o } \odot \pmb { c } ) \right) \oslash \pmb { c } ,
+$$
+
+where $\odot$ represents elementwise multiplication, and the rounded product can be folded into the bias $^ { b }$ as an optimization. This way, the representation is computed deterministically during evaluation, while during training, the marginal still resembles a smooth function, such that no regularization of the prior is necessary.
+
+# 6 EXPERIMENTAL RESULTS
+
+In order to assess the efficacy of integer networks to enable platform-independent compression and decompression, we re-implemented the image compression model described in Ballé et al. (2018), which is defined with a hyperprior. We compare the original model with a version in which the network $h _ { s }$ computing the prior is replaced with an integer network. We used the same network architectures in terms of number of layers, filters, etc., and the same training parameters as in the original paper. The rate–distortion performance of the model was assessed on Kodak (1993) and is shown in figure 3 (left). The modified model performs identically to the original model, as it maps out the same rate–distortion frontier. However, it is much more robust to cross-platform compression and decompression (table 1). We tested compression and decompression on four different platforms (two CPU platforms and two GPU platforms) and two different datasets, Tecnick (Asuni and Giachetti, 2014) and CLIC (2018). The original model fails to correctly decompress more than half of the images on average when compression and decompression occurs on different platforms. The modified model brings the failure rate down to $0 \%$ in all cases.
+
+![](images/a865c9ab4174bfbf3d830d1396893dbffeb412c482ec838ff0e3400b2afccbbb.jpg)  
+Figure 4: Loss function across training of Ballé (2018) model, evaluated on Kodak (1993), corresponding to the rate point at approximately 0.7 bits per pixel in figure 3, right panel. Generally, training of integer models takes somewhat longer and is somewhat noisier than training of floating point models. When matching floating point and integer networks for asymptotic performance (128 vs. 256 filters, respectively), integer networks take longer to converge (likely due to their larger number of filters). When matching by number of filters (128), it appears that the training time to convergence is about the same, but the performance ends up worse.
+
+It should be noted that the decreased accuracy of integer arithmetic generally leads to a lower approximation capacity than with floating point networks. We found that when implementing the models described in Ballé (2018) using integer networks throughout, the rate–distortion performance decreased (figure 3, right). The loss in approximation capacity can be compensated for by increasing the number of filters per layer. Note that this appears to increase the training time necessary for convergence (figure 4). However, note that increasing the number of parameters may not necessarily increase the size of the model parameters or the runtime, as the storage requirements for integer parameters (kernels, biases, etc.) are lower than for floating point parameters, and integer arithmetic is computationally less complex than floating point arithmetic in general.
+
+# 7 DISCUSSION
+
+There is a large body of recent research considering quantization of ANNs mostly targeted at image recognition applications. Courbariaux et al. (2015) train classification networks on lower precision multiplication. Hubara et al. (2016) and Rastegari et al. (2016) perform quantization down to bilevel (i.e., 1-bit integers) at inference time to reduce computation in classification networks. More recently, Wu et al. (2018) and others have used quantization during training as well as inference, to reduce computation on gradients as well as activations, and Baluja et al. (2018) use non-uniform quantization to remove floating point computation, replacing it completely with integer offsets into an integer lookup table.
+
+While the quantization of neural networks is not a new topic, the results from the above techniques focus almost exclusively on classification networks. Denton et al. (2014), Han et al. (2016), and others have demonstrated that these types of networks are particularly robust to capacity reduction.
+
+Models used for image compression, like many generative models, are much more sensitive to capacity constraints since they tend to underfit. As illustrated in Ballé (2018) and in figure 3 (right), this class of models is much more sensitive to reductions of capacity, both in terms of network size and the expressive power of the activation function. This may explain why our experiments with post-hoc quantization of network activations have never yielded competitive results for this class of model (not shown).
+
+As illustrated in figure 1 and table 1, small floating point inconsistencies in variational latent-variable models can have disastrous effects when we use range coding to employ the models for data compression across different hardware or software platforms. The reader may wonder whether there exists other entropy coding algorithms that can convert discrete latent-variable representations into a binary representation, and which do not suffer from a sensitivity to perturbations in the probability model. Unfortunately, such an algorithm would always produce suboptimal results for the following reason. The source coding theorem (Shannon, 1948) establishes a lower bound on the average length of the resulting bit sequences, which range coding achieves asymptotically (i.e. for long bit sequences). The lower bound is given by the cross entropy between the marginal and the prior:
+
+$$
+\mathbb { E } _ { { \pmb { y } } \sim m } [ | b ( { \pmb { y } } ) | ] \geq \mathbb { E } _ { { \pmb { y } } \sim m } [ - \log _ { 2 } p ( { \pmb { y } } \mid { \pmb { \theta } } ) ] ,
+$$
+
+where $\left| b ( \boldsymbol { y } ) \right|$ is the length of the binary representation of $\textbf {  { y } }$ . If an entropy coding algorithm tolerates error in the values of $p ( \pmb { y } \mid \pmb { \theta } )$ , this means it must operate under the assumption of identical probability values for a range of values of $\pmb { \theta } -$ in other words, discretize the probability values. Since the cross entropy is minimal only for $p ( \pmb { y } \mid \pmb { \theta } ) = m ( \pmb { y } )$ (for all $\textbf {  { y } }$ ), this would impose a new lower bound on $\left| b ( \pmb { y } ) \right|$ given by the cross entropy with the discretized probabilities, which is greater or equal to the cross entropy given above. Thus, the more tolerant the entropy coding method is to errors in $p$ , the further it deviates from optimal performance. Moreover, it is hard to establish tolerance intervals for probability values computed with floating point arithmetic, in particular when ANNs are used, due to error propagation. Hence, it is generally difficult to provide guarantees that a given tolerance will not be exceeded. For similar reasons, current commercial compression methods model probabilities exclusively in the discrete domain (e.g., using lookup tables; Marpe et al., 2003).
+
+Our approach to neural network quantization is the first we are aware of which specifically addresses non-deterministic computation, as opposed to computational complexity. It enables a variety of possible variational model architectures and distributions to be effectively used for platformindependent data compression. While we aren’t assessing its effects on computational complexity here, it is conceivable that complexity reductions can also be achieved with the same approach; this is a topic for future work.
+
+# REFERENCES
+
+Ágústsson, Eiríkur Þór et al. (2017). “Soft-to-Hard Vector Quantization for End-to-End Learning Compressible Representations”. In: Advances in Neural Information Processing Systems 30, pp. 1141–1151.   
+Alemi, Alexander A. et al. (2018). “Fixing a Broken ELBO”. In: arXiv e-prints. arXiv: 1711 . 00464.   
+Asuni, N. and A. Giachetti (2014). “TESTIMAGES: A large-scale archive for testing visual devices and basic image processing algorithms”. In: Proc. of STAG: Smart Tools and Apps for Graphics. DOI: 10.2312/stag.20141242.   
+Ballé, Johannes (2018). “Efficient Nonlinear Transforms for Lossy Image Compression”. In: Picture Coding Symposium (PCS), 2018.   
+Ballé, Johannes et al. (2018). “Variational image compression with a scale hyperprior”. In: Proc. of 6th Int. Conf. on Learning Representations. URL: https://openreview.net/forum? id $=$ rkcQFMZRb.   
+Baluja, Shumeet et al. (2018). “No Multiplication? No Floating Point? No Problem! Training Networks for Efficient Inference”. In: arXiv e-prints. arXiv: 1809.09244.   
+CLIC: Challenge on Learned Image Compression (2018). Mobile and Professional Datasets. URL: http://www.compression.cc/2018/challenge.   
+Courbariaux, Matthieu, Jean-Pierre David, and Yoshua Bengio (2015). “Training deep neural networks with low precision multiplications”. In: arXiv e-prints. Presented as a workshop contribution at the 3rd Int. Conf. on Learning Representations. arXiv: 1412.7024.   
+Cover, Thomas M. and Joy A. Thomas (2006). Elements of Information Theory. 2nd ed. Wiley.   
+Denton, Emily et al. (2014). “Exploiting Linear Structure Within Convolutional Networks for Efficient Evaluation”. In: Advances in Neural Information Processing Systems 27, pp. 1269–1277.   
+Han, Song, Huizi Mao, and William J. Dally (2016). “Deep Compression: Compressing Deep Neural Network with Pruning, Trained Quantization and Huffman Coding”. In: arXiv e-prints. Presented at the 4th Int. Conf. on Learning Representations. arXiv: 1510.00149.   
+Higgins, Irina et al. (2017). “ $\beta$ -VAE: Learning Basic Visual Concepts with a Constrained Variational Framework”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https : //openreview.net/forum?id $=$ Sy2fzU9gl.   
+Hubara, Itay et al. (2016). “Binarized Neural Networks”. In: Advances in Neural Information Processing Systems 29, pp. 4107–4115.   
+Jang, Eric, Shixiang Gu, and Ben Poole (2017). “Categorical Reparameterization with GumbelSoftmax”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https : / / openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rkE3y85ee.   
+Kingma, Diederik P. and Max Welling (2014). “Auto-Encoding Variational Bayes”. In: arXiv eprints. Presented at the 2nd Int. Conf. on Learning Representations. arXiv: 1312.6114.   
+Klopp, Jan P. et al. (2018). “Learning a Code-Space Predictor by Exploiting Intra-ImageDependencies”. In: Proc. of 29th British Machine Vision Conference.   
+Kodak, Eastman (1993). Kodak Lossless True Color Image Suite (PhotoCD PCD0992). URL: http://r0k.us/graphics/kodak/.   
+Marpe, Detlev, Heiko Schwarz, and Thomas Wiegand (2003). “Context-Based Adaptive Binary Arithmetic Coding in the H.264/AVC Video Compression Standard”. In: IEEE Transactions on Circuits and Systems for Video Technology 13.7. DOI: 10.1109/TCSVT.2003.815173.   
+Minnen, David, Johannes Ballé, and George Toderici (2018). “Joint Autoregressive and Hierarchical Priors for Learned Image Compression”. In: Advances in Neural Information Processing Systems 31, pp. 10771–10780.   
+Oord, Aäron van den, Oriol Vinyals, and Koray Kavukcuoglu (2017). “Neural Discrete Representation Learning”. In: Advances in Neural Information Processing Systems 30, pp. 6306–6315.   
+Rastegari, Mohammad et al. (2016). “XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks”. In: ECCV 2016. Lecture Notes in Computer Science. Vol. 9908. DOI: 10.1007/978-3-319-46493-0_32.   
+Rissanen, Jorma and Glen G. Langdon Jr. (1981). “Universal modeling and coding”. In: IEEE Transactions on Information Theory 27.1. DOI: 10.1109/TIT.1981.1056282.   
+Shannon, Claude E. (1948). “A Mathematical Theory of Communication”. In: The Bell System Technical Journal 27.3. DOI: 10.1002/j.1538-7305.1948.tb01338.x.   
+Sønderby, Casper Kaae et al. (2016). “Ladder variational autoencoders”. In: Advances in Neural Information Processing Systems 29, pp. 3738–3746.   
+Theis, Lucas et al. (2017). “Lossy Image Compression with Compressive Autoencoders”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https://openreview.net/forum? id $=$ rJiNwv9gg.   
+Wu, Shuang et al. (2018). “Training and Inference with Integers in Deep Neural Networks”. In: Proc. of 6th Int. Conf. on Learning Representations. URL: https://openreview.net/ forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HJGXzmspb.

parse/train/S1zz2i0cY7/S1zz2i0cY7_content_list.json

@@ -0,0 +1,1106 @@
+[
+    {
+        "type": "text",
+        "text": "INTEGER NETWORKS FOR DATA COMPRESSION WITH LATENT-VARIABLE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            740,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Johannes Ballé, Nick Johnston & David Minnen Google Mountain View, CA 94043, USA {jballe,nickj,dminnen}@google.com ",
+        "bbox": [
+            184,
+            169,
+            517,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of using variational latent-variable models for data compression. For such models to produce a compressed binary sequence, which is the universal data representation in a digital world, the latent representation needs to be subjected to entropy coding. Range coding as an entropy coding technique is optimal, but it can fail catastrophically if the computation of the prior differs even slightly between the sending and the receiving side. Unfortunately, this is a common scenario when floating point math is used and the sender and receiver operate on different hardware or software platforms, as numerical round-off is often platform dependent. We propose using integer networks as a universal solution to this problem, and demonstrate that they enable reliable cross-platform encoding and decoding of images using variational models. ",
+        "bbox": [
+            233,
+            299,
+            764,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The task of information transmission in today’s world is largely divided into two separate endeavors: source coding, or the representation of data (such as audio or images) as sequences of bits, and channel coding, representing sequences of bits as analog signals on imperfect, physical channels such as radio waves (Cover and Thomas, 2006). This decoupling has substantial benefits, as the binary representations of arbitrary data can be seamlessly transmitted over arbitrary physical channels by only changing the underlying channel code, rather than having to design a new code for every possible combination of data source and physical channel. Hence, the universal representation of any compressed data today is the binary channel, a representation which consists of a variable number of binary symbols, each with probability $\\textstyle { \\frac { 1 } { 2 } }$ , and no noise (i.e. uncertainty). ",
+        "bbox": [
+            173,
+            518,
+            825,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As a latent representation, the binary channel unfortunately is a severe restriction compared to the richness of latent representations defined by many variational latent-variable models in the literature (e.g., Kingma and Welling, 2014; Sønderby et al., 2016; van den Oord et al., 2017), and in particular models targeted at data compression (Theis et al., 2017; Ágústsson et al., 2017; Ballé et al., 2018). Variational latent-variable models such as VAEs (Kingma and Welling, 2014) consist of an encoder model distribution $e ( \\pmb { y } \\mid \\pmb { x } )$ bringing the data $_ { \\textbf { \\em x } }$ into a latent representation $\\textbf {  { y } }$ , and a decoder model distribution $d ( { \\pmb x } \\mid { \\pmb y } )$ , which represents the data likelihood conditioned on the latents. Given an encoder $e$ , we observe the marginal distribution of latents $m ( \\pmb { y } ) = \\mathbb { E } _ { \\pmb { x } } [ e ( \\pmb { y } \\mid \\pmb { x } ) ]$ , where the expectation runs over the (unknown) data distribution. The prior $p ( \\pmb { y } )$ is a variational estimate of the marginal (Alemi et al., 2018). ",
+        "bbox": [
+            173,
+            651,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By choosing the parametric forms of these distributions and the training objective appropriately, many such models succeed in representing relevant information in the data they are trained for quite compactly (i.e., with a small expected Kullback–Leibler (KL) divergence between the encoder and the prior, $\\begin{array} { r } { \\mathbb { E } _ { \\pmb { x } } D _ { \\mathrm { K L } } [ e \\| p ] ) } \\end{array}$ , and so may be called compressive in a sense. However, not all of them can be directly used for practical data compression, as the representation needs to be further converted into binary (entropy encoded). This conversion is typically performed by range coding, or arithmetic coding (Rissanen and Langdon, 1981). Range coding is asymptotically optimal: the length of the binary sequence quickly converges to the expected KL divergence in bits, for reasonably large sequences (such as, for one image). For this to hold, the following requirements must be satisfied: ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6a6648bd111c33790c9a0a1e49addb8c95065b786817c864c1cea610843d505.jpg",
+        "image_caption": [
+            "Figure 1: The same image, decoded with a model computing the prior using integer arithmetic (left), and the same model using floating point arithmetic (right). The image was decoded correctly, beginning in the top-left corner, until floating point round-off error caused a small discrepancy between the sender’s and the receiver’s copy of the prior, at which point the error propagated catastrophically. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            826,
+            268
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• The representation must be discrete-valued, i.e. have a finite number of states, and be noiseless – i.e. the conditional entropy of the encoder must be zero: ",
+        "bbox": [
+            215,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/430dff0a889fb943e29c48983aae0adcc3a9bda733edb62b41e761ff8e7055b5.jpg",
+        "text": "$$\nH [ e ] = \\mathbb { E } _ { \\pmb { x } } \\mathbb { E } _ { \\pmb { y } \\sim e } [ - \\log e ( \\pmb { y } \\mid \\pmb { x } ) ] = 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            398,
+            655,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• All scalar elements of the representation $\\textbf {  { y } }$ must be brought into a total ordering, and the prior needs to be written using the chain rule of calculus (as a product of conditionals), as the algorithm can only encode or decode one scalar random variable at a time. ",
+        "bbox": [
+            215,
+            425,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Both sides of the binary channel (i.e. sender and receiver) must be able to evaluate the prior, and they must have identical instances of it. ",
+        "bbox": [
+            215,
+            472,
+            823,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The latter point is crucial, as range coding is extremely sensitive to differences in $p$ between sender and receiver – so sensitive, in fact, that even small perturbations due to floating point round-off error can lead to catastrophic error propagation. Unfortunately, numerical round-off is highly platform dependent, and in typical data compression applications, sender and receiver may well employ different hardware or software platforms. Round-off error may even be non-deterministic on one and the same computer. Figure 1 illustrates a decoding failure in a model which computes $p$ using floating point math, caused by such computational non-determinism in sender vs. receiver. Recently, latent-variable models have been explored that employ artificial neural networks (ANNs) to compute hierarchical or autoregressive priors (Sønderby et al., 2016; van den Oord et al., 2017), including some of the best-performing learned image compression models (Ballé et al., 2018; Minnen et al., 2018; Klopp et al., 2018). Because ANNs are typically based on floating point math, these methods are vulnerable to catastrophic failures when deployed on heterogeneous platforms. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            679
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address this problem, and enable use of powerful learned variational models for real-world data compression, we propose to use integer arithmetic in these ANNs, as floating-point arithmetic cannot presently be made deterministic across arbitrary platforms. We formulate a type of quantized neural network we call integer networks, which are specifically targeted at generative and compression models, and at preventing computational non-determinism in computation of the prior. Because full determinism is a feature of many existing, widely used image and video compression methods, we also consider using integer networks end to end for computing the representation itself. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 INTEGER NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            797,
+            454,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ANNs are typically composite functions that alternate between linear and elementwise nonlinear operations. One linear operation followed by a nonlinearity is considered one layer of the network. To ensure that such a network can be implemented deterministically on a wide variety of hardware platforms, we restrict all the data types to be integral, and all operations to be implemented either with basic arithmetic or lookup tables. Because integer multiplications (including matrix multiplications or convolutions) increase the dynamic range of the output compared to their inputs, we introduce an additional step after each linear operator, where we divide each of its output by a learned parameter. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c91a76ad0addf5cef94c1363679199123dda26f8a6a06cc57fa964c0de157f07.jpg",
+        "image_caption": [
+            "Figure 2: Left: Example nonlinearity implementing a saturating rectifier for 4-bit unsigned integer outputs, given by $g _ { \\mathrm { Q R e L U } } ( v ) = \\mathrm { m a x } ( \\mathrm { m i n } ( v , 1 5 ) , 0 )$ . This nonlinearity can be implemented deterministically either using a lookup table or simply using a clipping operation. The corresponding scaled cumulative of a generalized Gaussian with $\\beta = 4$ used for computing gradients is plotted in cyan, and other choices of $\\beta$ in gray. Right: Example nonlinearity approximating hyperbolic tangent for 4-bit signed integer outputs, given by $\\begin{array} { r } { g _ { \\mathrm { Q t a n h } } ( v ) = Q ( 7 \\operatorname { t a n h } ( \\frac { v } { 1 5 } ) ) } \\end{array}$ . This nonlinearity can be implemented deterministically using a lookup table. The corresponding scaled hyperbolic tangent used for computing gradients is plotted in cyan. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            826,
+            261
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concretely, we define the relationship between inputs $\\textbf { \\em u }$ and outputs $\\pmb { w }$ of one layer as: ",
+        "bbox": [
+            171,
+            411,
+            741,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce8662bd1d7fc1b5a6a25eb34e6f32e599e0b3eee84dbc30fa3074ec7a8052f0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { v } = ( \\pmb { H } \\pmb { u } + \\pmb { b } ) \\oslash \\pmb { c } , } \\\\ { \\pmb { w } = g ( \\pmb { v } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            431,
+            568,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order, the inputs $\\textbf { \\em u }$ are subjected to a linear transform $\\pmb { H }$ (a matrix multiplication, or a convolution); a bias vector $^ { b }$ is added; the result is divided elementwise by a vector $^ c$ , yielding an intermediate result vector $\\textbf {  { v } }$ ; and finally, an elementwise nonlinearity $g$ is applied to $\\pmb { v }$ . ",
+        "bbox": [
+            174,
+            473,
+            823,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The activations $\\textbf { \\em w }$ and all intermediate results, as well as the parameters $H , b$ , and $^ c$ are all defined as integers. However, they may use differing number formats. For $\\pmb { v }$ to be integral, we define $\\oslash$ here to perform rounding division (equivalent to division followed by rounding to the nearest integer). In programming languages such as C, this can be implemented with integer operands $m , n$ as ",
+        "bbox": [
+            173,
+            522,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ed009fa80d9626f5fa79793ff68d2a7c7aa65c2ae0feec3d06db5eac912637f9.jpg",
+        "text": "$$\n\\begin{array} { r } { m \\oslash n = Q ( \\frac { m } { n } ) = ( m + n / / 2 ) \\ / / n , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            584,
+            622,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $Q$ rounds to the nearest integer and $/ /$ is floor division; here, the addition can be folded into the bias $^ { b }$ as an optimization. We constrain the linear filter coefficients $\\pmb { H }$ and the bias vector $^ { b }$ to generally use signed integers, and the scaling vector $^ c$ to use unsigned integers. We implement the accumulators of the linear transform with larger bit width than the activations and filter coefficients, in order to reflect the potentially increased dynamic range of multiplicative operations. We assume here that the bias and scaling vectors, as well as the intermediate vector $\\pmb { v }$ , have the same bit width as the accumulators. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The elementwise nonlinearity $g$ must be saturating on both ends of its domain, because integers can only represent finite number ranges. In order to maximize utility of the dynamic range, we scale nonlinearities such that their range matches the bit width of $\\pmb { w }$ , while their domain can be scaled somewhat arbitrarily. Depending on the range of the nonlinearity, the activations $\\textbf { \\em w }$ may use a signed or unsigned number format. For instance, a reasonable choice of number formats and nonlinearity would be: ",
+        "bbox": [
+            173,
+            712,
+            825,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe3f008418a79eb1a359d809f9a965ca060c64629f36c823a6b4d86af5b9a8df.jpg",
+        "text": "$$\n\\begin{array} { c } { { H : 8 \\mathrm { - b i t ~ s i g n e d ~ } } } \\\\ { { b , v : 3 2 \\mathrm { - b i t ~ s i g n e d ~ ( s a m e ~ a s ~ a c c u m u l a t o r ) } } } \\\\ { { c : 3 2 \\mathrm { - b i t ~ u n s i g n e d ~ } } } \\\\ { { w : 8 \\mathrm { - b i t ~ u n s i g n e d ~ } } } \\\\ { { g _ { \\mathrm { Q R e L U } } ( v ) = \\mathrm { m a x } ( \\mathrm { m i n } ( v , 2 5 5 ) , 0 ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            800,
+            658,
+            891
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this example, the nonlinearity can be implemented with a simple clipping operation. Refer to figure 2, left, for a visualization (for visualization purposes, the figure shows a smaller bit width). ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another example is: ",
+        "bbox": [
+            176,
+            103,
+            307,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc95b1f0d28bdf8a82da442b2265bec7cc26d2ececebf5f0d4d876d0774c11d0.jpg",
+        "text": "$$\n\\begin{array} { r } { g _ { \\mathrm { Q t a n h } } ( v ) = Q \\bigl ( 7 \\operatorname { t a n h } ( \\frac { v } { 1 5 } ) \\bigr ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            198,
+            526,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, the nonlinearity approximates the hyperbolic tangent, a widely used nonlinearity. It may be best implemented using a lookup table (see figure 2, right, for a visualization). We scale its range to fill the 4-bit signed integer number format of $\\pmb { w }$ by multiplying its output with 7. The domain can be scaled somewhat arbitrarily, since $\\pmb { v }$ has a larger bit width than $\\pmb { w }$ . When it is chosen too small, $\\pmb { w }$ may not utilize all integer values, leading to a large quantization error. When it is chosen too large, overflow may occur in $\\pmb { v }$ , or the size of the lookup table may grow too large for practical purposes. Therefore, it is best to determine the input scaling based on the shape of the nonlinearity and the available dynamic range. Here, we simply chose the value of 15 “by eye”, so that the nonlinearity is reasonably well represented with the lookup table (i.e., we made sure that at least two or three input values are mapped to each output value, in order to preserve the approximate shape of the nonlinearity). ",
+        "bbox": [
+            173,
+            223,
+            826,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TRAINING INTEGER NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            391,
+            545,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To effectively accumulate small gradient signals, we train the networks entirely using floating point computations, rounded to integers after every computational operation, while the backpropagation is done with full floating point precision. More concretely, we define the integer parameters $H , b ,$ and $^ c$ as functions of their floating point equivalents $H ^ { \\prime } , b ^ { \\prime }$ , and $c ^ { \\prime }$ , respectively: ",
+        "bbox": [
+            173,
+            419,
+            825,
+            476
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c5fab5e1106a5f19986b471317b0cace4da7facbec6fe3276f8ec72272a666d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\boldsymbol { H } = \\left[ \\begin{array} { c } { Q ( h _ { 1 } ^ { \\prime } / s ( h _ { 1 } ^ { \\prime } ) ) ) } \\\\ { \\vdots } \\\\ { Q ( h _ { N } ^ { \\prime } / s ( h _ { N } ^ { \\prime } ) ) } \\end{array} \\right] , } \\\\ & { ~ b = Q \\big ( 2 ^ { K } b ^ { \\prime } \\big ) , } \\\\ & { \\boldsymbol { c } = Q \\big ( 2 ^ { K } r ( \\boldsymbol { c } ^ { \\prime } ) \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            483,
+            584,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we simply rescale each element of $\\pmb { b } ^ { \\prime }$ using a constant $K$ , which is the bit-width of the kernel $\\pmb { H }$ (e.g. 8-bits in the QReLu networks), and round it to the nearest integer. The reparameterization mapping $r$ is borrowed from Ballé (2018): ",
+        "bbox": [
+            173,
+            588,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f05f14dee3381c0df2a2f328de637c63d32eee81f98dd6f4752b463161af90d9.jpg",
+        "text": "$$\nr ( c ^ { \\prime } ) = \\mathrm { m a x } \\Big ( c ^ { \\prime } , \\sqrt { 1 + \\epsilon ^ { 2 } } \\Big ) ^ { 2 } - \\epsilon ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            637,
+            614,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When $^ c$ is small, perturbations in $^ c$ can lead to excessively large fluctuations of the quotient (i.e., the input to the nonlinearity). This leads to instabilities in training. $r$ ensures that values of $^ c$ are always positive, while gracefully scaling down gradient magnitudes on $^ c$ near zero. Effectively, the step size on $^ c$ is multiplied with a factor that is approximately linear in $^ c$ (Ballé, 2018). ",
+        "bbox": [
+            173,
+            674,
+            825,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before rounding the linear filter coefficients in $\\pmb { H } ^ { \\prime } = [ h _ { 1 } ^ { \\prime } , \\ldots , h _ { N } ^ { \\prime } ] ^ { \\top }$ , we apply a special rescaling function $s$ to each of its filters $\\mathbf { { } } h ^ { \\prime }$ : ",
+        "bbox": [
+            173,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/57b15f6a4c1f94326ab3a5538cc460fb940a23a55e4b65800eddd132c700c6f4.jpg",
+        "text": "$$\ns ( h ^ { \\prime } ) = \\mathrm { m a x } \\Big ( ( - 2 ^ { K - 1 } ) ^ { - 1 } \\operatorname* { m i n } _ { i } h _ { i } ^ { \\prime } , ( 2 ^ { K - 1 } - 1 ) ^ { - 1 } \\operatorname* { m a x } _ { i } h _ { i } ^ { \\prime } , \\epsilon \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            770,
+            704,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$s$ rescales each filter such that at least one of its minimum and maximum coefficients hits one of the dynamic range bounds $( - 2 ^ { K - 1 }$ and $2 ^ { K - 1 } - 1 )$ ), while keeping zero at zero. This represents the finest possible quantization of the filter given its integer representation, and thus maximizes accuracy. To prevent division by zero, we ensure the divisor is larger than or equal to a small constant $\\epsilon$ (for example, $\\epsilon = 1 0 ^ { - \\tilde { 2 } 0 }$ ). ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to backpropagate gradient signals into the parameters, one cannot simply take gradients of the loss function with respect to $H ^ { \\prime }$ , $\\pmb { b } ^ { \\prime }$ , or $c ^ { \\prime }$ , since the rounding function $Q$ has zero gradients almost everywhere, except for the half-integer positions where the gradient is positive infinity. A simple remedy is to replace the derivative of $Q$ with the identity function, since this is the smoothed gradient across all rounded values. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Further, we treat the rescaling divisor $s$ as if it were a constant. That is, we compute the derivatives of the loss function with respect to $H ^ { \\prime } , b ^ { \\prime }$ , and $c ^ { \\prime }$ as with the chain rule of calculus, but overriding: ",
+        "bbox": [
+            171,
+            138,
+            821,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9dcdab371e0ac3c891e10b51a1ac5565b11f72012c44c2cab17a641ac3c7d56f.jpg",
+        "text": "$$\n\\frac { \\partial h } { \\partial h ^ { \\prime } } : = \\frac { 1 } { s ( h ^ { \\prime } ) } , \\qquad \\frac { \\partial b } { \\partial b ^ { \\prime } } : = 2 ^ { K } , \\qquad \\frac { \\partial c } { \\partial c ^ { \\prime } } : = 2 ^ { K } r ^ { \\prime } ( c ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            167,
+            679,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $r ^ { \\prime }$ is the replacement gradient function for $r$ as proposed by Ballé (2018). After training is completed, we compute the integer parameters $\\pmb { H }$ , $^ { b }$ and $^ c$ one more time, and from then on use them for evaluation. Note that further reparameterization of the kernels $H ^ { \\prime }$ , such as Sadam (Ballé, 2018), or of the biases $\\pmb { b } ^ { \\prime }$ or scaling parameters $c ^ { \\prime }$ , is possible by simply chaining reparameterizations. ",
+        "bbox": [
+            173,
+            202,
+            825,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition to rounding the parameters, it is necessary to round the activations. To obtain gradients for the rounding division $\\oslash$ , we simply substitute the gradient of floating point division. To estimate gradients for the rounded activation functions, we replace their gradient with the corresponding nonrounded activation function, plotted in cyan in figure 2. In the case of QReLU, the gradient of the clipping operation is a box function, which can lead to training getting stuck, since if activations consistently hit one of the bounds, no gradients are propagated back (this is sometimes called the “dead unit” problem). As a remedy, we replace the gradient instead with ",
+        "bbox": [
+            173,
+            263,
+            825,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bd5e5b014f1b8ecea4471bd1b8419a80013ba1ea95ef323be837e2024dba8c0.jpg",
+        "text": "$$\n\\frac { \\partial g _ { \\mathrm { Q R e L U } } ( v ) } { \\partial v } : = \\exp \\Bigl ( - \\alpha ^ { \\beta } \\Bigl | \\frac { 2 v } { 2 ^ { L } - 1 } - 1 \\Bigr | ^ { \\beta } \\Bigr ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            363,
+            642,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\alpha = \\frac { 1 } { \\beta } \\Gamma \\left( \\frac { 1 } { \\beta } \\right) } \\end{array}$ , and $L$ is the bit width of $\\textbf { \\em w }$ . This function corresponds to a scaled generalized Gaussian probability density with shape parameter $\\beta$ . In this context, we can think of $\\beta$ as a temperature parameter that makes the function converge to the gradient of the clipping operation as $\\beta$ goes to infinity. Although this setting permits an annealing schedule, we simply chose $\\beta = 4$ and obtained good results. The integral of this function is plotted in figure 2 (left) in cyan, along with other choices of $\\beta$ in gray. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 COMPUTING THE PRIOR WITH INTEGER NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            632,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose our prior on the latent representation is $p ( \\pmb { y } \\mid z )$ , where $_ z$ summarizes other latent variables of the representation (it may be empty). To apply range coding, we need to impose a total ordering on the elements of $\\textbf {  { y } }$ and write it as a chain of conditionals: ",
+        "bbox": [
+            173,
+            526,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b81a38a72d7a4a93351af7c7855836877083f200b8973e92fd9c159877db3f8.jpg",
+        "text": "$$\np ( \\pmb { y } \\mid z ) = \\prod _ { i } p ( y _ { i } \\mid \\pmb { y } _ { : i } , z ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            570,
+            593,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\nabla } _ { \\mathbf { { \\boldsymbol { y } } } : i }$ denotes the vector of all elements of $\\textbf {  { y } }$ preceding the ith. A common assumption is that $p$ is a known distribution, with parameters $\\theta _ { i }$ computed by an $\\operatorname { A N N } g$ : ",
+        "bbox": [
+            176,
+            603,
+            823,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/723b71d7b3fae2ceb75f637c854496d30080baa5379bfedefff53ac018895d1f.jpg",
+        "text": "$$\np ( \\pmb { y } \\mid z ) = \\prod _ { i } p ( y _ { i } \\mid \\pmb { \\theta } _ { i } ) \\operatorname { w i t h } \\pmb { \\theta } _ { i } = g ( \\pmb { y } _ { : i } , z )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            632,
+            647,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We simply propose here to compute $g$ deterministically using an integer network, discretizing the parameters $\\pmb \\theta$ to a reasonable accuracy. If $p ( y _ { i } \\mid \\pmb \\theta _ { i } )$ itself cannot be computed deterministically, we can precompute all possible values and express it as a lookup table over $y _ { i }$ and $\\theta _ { i }$ . ",
+        "bbox": [
+            173,
+            665,
+            825,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As an example, consider the prior used in the image compression model proposed by Ballé et al. (2018), which is a modified Gaussian with scale parameters conditioned on another latent variable: ",
+        "bbox": [
+            173,
+            713,
+            820,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df784c2bf29be4c8224f794cc3a592fc4cfc5163742ff09ba5cde4b3acc2bc28.jpg",
+        "text": "$$\np ( \\pmb { y } \\mid z ) = \\prod _ { i } \\left( \\mathcal { N } ( 0 , \\sigma _ { i } ^ { 2 } ) * \\mathcal { U } ( - \\textstyle \\frac { 1 } { 2 } , \\textstyle \\frac { 1 } { 2 } ) \\right) ( y _ { i } ) \\mathrm { w i t h } \\sigma = g ( z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            743,
+            692,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We reformulate the scale parameters $\\sigma$ as: ",
+        "bbox": [
+            176,
+            776,
+            450,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/002e76f31249019d2bc4dce05d0d356ad9f4f4cec3c7e7e515eee472faad9513.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sigma _ { i } = \\exp \\Bigl ( \\log \\bigl ( \\sigma _ { \\operatorname* { m i n } } \\bigr ) + \\frac { \\log \\left( \\sigma _ { \\operatorname* { m a x } } \\right) - \\log \\left( \\sigma _ { \\operatorname* { m i n } } \\right) } { L - 1 } \\theta _ { i } \\Bigr ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            791,
+            645,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb \\theta = g ( z )$ is computed using an integer network. The last activation function in $g$ is chosen to have integer outputs of $L$ levels in the range $[ 0 , L - 1 ]$ . Constants $\\sigma _ { \\mathrm { m i n } }$ , $\\sigma _ { \\mathrm { m a x } }$ , and $L$ determine the discretized selection of scale parameters used in the model. The discretization is chosen to be logarithmic, as this choice minimizes $\\mathbb { E } _ { \\pmb { x } } D _ { \\mathrm { K L } } [ e \\Vert p ]$ for a given number of levels. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During training, we can simply backpropagate through this reformulation, and through $g$ as described in the previous section. After training, we precompute all possible values of $p$ as a function of $y _ { i }$ and $\\theta _ { i }$ and form a lookup table, while $g$ is implemented with integer arithmetic. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For certain applications, it can be useful not only to be able to deploy a compression model across heterogenous platforms, but to go even further in also ensuring identical reconstructions of the data across platforms. To this end, it can be attractive to make the entire model robust to non-determinism. To use integer networks in the encoder or decoder, one can use the equivalent construction as in (13): define $e$ or $d$ as a known distribution, with parameters computed by an integer network. To allow the use of range coding, we’re especially interested in discrete-valued representations here, such as studied in van den Oord et al. (2017), Jang et al. (2017), Theis et al. (2017), Ágústsson et al. (2017), and Ballé et al. (2018), among others. These approaches typically employ biased gradient estimators. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Jang et al. (2017) and Ágústsson et al. (2017) are concerned with producing gradients for categorical distributions and vector quantization (VQ), respectively. In both methods, the representation is found by evaluating an ANN followed by an arg max function, while useful gradients are obtained by substituting the arg max with a softmax function. Since arg max can be evaluated deterministically in a platform-independent way, and evaluating a softmax function with rounded inputs is feasible, integer networks can be combined with these models without additional modifications. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theis et al. (2017) and Ballé et al. (2018) differ mostly in the details of interaction between the encoder and the prior. These two approaches are particularly interesting for image compression, as they scale well: Image compression models are often trained with a rate–distortion objective with a Lagrange parameter $\\lambda$ , equivalent to $\\beta$ in the $\\beta$ -VAE objective (Higgins et al., 2017; Alemi et al., 2018). Depending on the parameter, the latent representation carries vastly different amounts of information, and the optimal number of latent states in turn varies with that. While the number of latent states is a hyperparameter that needs to be chosen ahead of time in the categorical/VQ case, the latter two approaches can extend it as needed during training, because the latent states are organized along the real line. Further, for categorical distributions as well as VQ, the required dimensionality of the function computing the parameters grows linearly with the number of latent states due to their use of the arg max function. In the latter two models, the number of states can grow arbitrarily without increasing the dimensionality of $g$ . ",
+        "bbox": [
+            173,
+            353,
+            825,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Both Theis et al. (2017) and Ballé et al. (2018) use deterministic encoder distributions (i.e. degenerating to delta distributions) during evaluation, but replace them with probabilistic versions for purposes of estimating $\\mathbb { E } _ { \\pmb { x } } D _ { \\mathrm { K L } } [ e \\Vert p ]$ during training. Theis et al. (2017) propose to use the following encoder distribution: ",
+        "bbox": [
+            174,
+            527,
+            823,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4018eb58a2925f4a556ccf5ddf500c6b355fec0471e7bc348858809e61666513.jpg",
+        "text": "$$\n\\begin{array} { r } { e ( \\pmb { y } \\mid \\pmb { x } ) = \\mathcal { U } ( \\pmb { y } \\mid Q ( g ( \\pmb { x } ) ) - \\frac { 1 } { 2 } , Q ( g ( \\pmb { x } ) ) + \\frac { 1 } { 2 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            582,
+            655,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { U }$ is the uniform distribution and $g$ is an ANN. They replace the gradient of the quantizer with the identity. During evaluation, $\\pmb { y } = Q ( g ( \\pmb { x } ) )$ is used as the representation. Ballé et al. (2018) use the following distribution during training: ",
+        "bbox": [
+            178,
+            601,
+            823,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2896319ede8c255b82cd7a7f3de1996e7edb3bb2da063222a41b0132c3e9bb4d.jpg",
+        "text": "$$\n\\begin{array} { r } { e ( \\pmb { y } \\mid \\pmb { x } ) = \\mathcal { U } ( \\pmb { y } \\mid g ( \\pmb { x } ) - \\frac { 1 } { 2 } , g ( \\pmb { x } ) + \\frac { 1 } { 2 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            645,
+            630,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which makes $\\textbf {  { y } }$ shift-invariant. During evaluation, they determine the representation as ${ \\textbf { 3 } } =$ $Q ( g ( \\pmb { x } ) - \\pmb { o } )$ , where $^ o$ is a sub-integer offset chosen such that the mode (or, if it cannot be estimated easily, the median) of the distribution is centered on one of the quantization bins. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If $g$ is implemented with integer networks, the latter approach becomes equivalent to the former, because $g$ then inherently computes integer outputs, and this is effectively equivalent to the quantization in (16). However, we’ve found that training with this construction leads to instabilities, such that the prior distribution never converges to a stable set of parameters. The reason may be that with quantization in $e$ , the marginal $m ( \\bar { \\pmb { y } } ) = \\mathbb { E } _ { \\pmb { x } } e ( \\pmb { y } \\mid \\pmb { x } )$ resembles a piecewise constant function, while the prior $p$ must be forced to be smooth, or $\\mathbb { E } _ { \\pmb { x } } D _ { \\mathrm { K L } } [ e \\Vert p ]$ would not yield any useful gradients. Because the prior is a variational approximation of the marginal, this means that the prior must be regularized (which we did not attempt here – we used the nonparametric density model described in Ballé et al. (2018)). On the other hand, when using (17) without quantization, the marginal is typically a smooth density, and the prior can approximate it closely without the need for regularization. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a remedy for the instabilities, we propose the following trick: We simply use (17) during training, but define the last layer of $g$ without a nonlinearity and with floating point division, such that the representation is ",
+        "bbox": [
+            174,
+            862,
+            825,
+            905
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd15f528d275a906ce34c1944e5d748cc721f84d236c3274ac353e4e1fdc1e1e.jpg",
+        "text": "$$\n\\begin{array} { r } { e ( \\pmb { y } \\mid \\pmb { x } ) = \\mathcal { U } ( \\pmb { y } \\mid ( \\pmb { H } \\pmb { u } + \\pmb { b } ) / c - \\frac { 1 } { 2 } , ( \\pmb { H } \\pmb { u } + \\pmb { b } ) / c + \\frac { 1 } { 2 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            906,
+            684,
+            926
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4169eee3870fc1b30ed28c0ec26e0fa7b41d213ef75cb24efacfc3951184acc1.jpg",
+        "image_caption": [
+            "Figure 3: Rate–distortion performance of image compression models with integer priors (left and up is better). Left: performance of Ballé et al. (2018) model vs. the same model with an integer prior. The performance is identical, but the latter can be reliably deployed across different hardware platforms. Right: performance of Ballé (2018) ReLU model with 128 filters per layer vs. the same model, with integer transforms and QReLU activation functions and 128 or 256 filters per layer. The approximation capacity of integer networks is diminished vs. floating point networks, but doubling the number of filters per layer more than compensates for the loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            826,
+            301
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/de3d5491ab19c9ba29340ad9eca07f4406914fc7c8869f9143cf02cb37d1a068.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "CPU 1: Intel Xeon E5-1650 GPU 1: NVIDIA Titan X (Pascal) CPU 2: Intel Xeon E5-2690 GPU 2: NVIDIA Titan X (Maxwell) "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>compressed ondecompressed on</td><td rowspan=1 colspan=1>CPU 1CPU 1</td><td rowspan=1 colspan=1>CPU 1GPU 1</td><td rowspan=1 colspan=1>CPU 1CPU 2</td><td rowspan=1 colspan=1>CPU 1GPU 2</td><td rowspan=1 colspan=1>GPU 1CPU 1</td><td rowspan=1 colspan=1>GPU 1GPU 1</td><td rowspan=1 colspan=1>GPU 1CPU 2</td><td rowspan=1 colspan=1>GPU 1GPU 2</td></tr><tr><td rowspan=1 colspan=9>Tecnick dataset:100 RGB i3 images of 1200 × 1200 pixels</td></tr><tr><td rowspan=1 colspan=1>Ballé et al. (2018)ditto, integer prior</td><td rowspan=1 colspan=1>0%0%</td><td rowspan=1 colspan=1>71%0%</td><td rowspan=1 colspan=1>54%0%</td><td rowspan=1 colspan=1>66%0%</td><td rowspan=1 colspan=1>63%0%</td><td rowspan=1 colspan=1>41%0%</td><td rowspan=1 colspan=1>59%0%</td><td rowspan=1 colspan=1>34%0%</td></tr><tr><td rowspan=1 colspan=9> CLIC dataset: 2021 RGB images of various pixel sizes</td></tr><tr><td rowspan=1 colspan=1>Ballé et al. (2018)ditto, integer prior</td><td rowspan=1 colspan=1>0%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>68%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>77%0%</td><td rowspan=1 colspan=1>52%0%</td><td rowspan=1 colspan=1>78%0%</td><td rowspan=1 colspan=1>54%0%</td></tr></table>",
+        "bbox": [
+            171,
+            426,
+            826,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Decompression failure rates due to floating point round-off error on Tecnick and CLIC image datasets. When compressing and decompressing on the same CPU platform (first column), the Ballé et al. (2018) model decompresses all images correctly. However, when compressing on a GPU or decompressing on a different platform, a large percentage of the images fail to be decoded correctly. Implementing the prior of the same model using integer networks ensures correct decompression across all tested platforms. ",
+        "bbox": [
+            173,
+            594,
+            825,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "during training, where $\\textbf { \\em u }$ is the input to the last layer and $/$ represents elementwise floating point division, and ",
+        "bbox": [
+            171,
+            705,
+            823,
+            733
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04fafd8d6ad8dbb52c1f821552ac363dfe9dae5846aa8167bb2cfaafc5fbd817.jpg",
+        "text": "$$\n{ \\pmb y } = Q \\big ( ( { \\pmb H } { \\pmb u } + { \\pmb b } ) / c - o \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            731,
+            588,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "during evaluation. This can be rewritten strictly using integer arithmetic as: ",
+        "bbox": [
+            173,
+            752,
+            668,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a63f5230a7295667dafce708a4401fd4832872f60756398bec1621b656ecb170.jpg",
+        "text": "$$\n\\pmb { y } = \\left( \\pmb { H } \\pmb { u } + \\pmb { b } - \\pmb { Q } ( \\pmb { o } \\odot \\pmb { c } ) \\right) \\oslash \\pmb { c } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            772,
+            609,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ represents elementwise multiplication, and the rounded product can be folded into the bias $^ { b }$ as an optimization. This way, the representation is computed deterministically during evaluation, while during training, the marginal still resembles a smooth function, such that no regularization of the prior is necessary. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            867,
+            416,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to assess the efficacy of integer networks to enable platform-independent compression and decompression, we re-implemented the image compression model described in Ballé et al. (2018), which is defined with a hyperprior. We compare the original model with a version in which the network $h _ { s }$ computing the prior is replaced with an integer network. We used the same network architectures in terms of number of layers, filters, etc., and the same training parameters as in the original paper. The rate–distortion performance of the model was assessed on Kodak (1993) and is shown in figure 3 (left). The modified model performs identically to the original model, as it maps out the same rate–distortion frontier. However, it is much more robust to cross-platform compression and decompression (table 1). We tested compression and decompression on four different platforms (two CPU platforms and two GPU platforms) and two different datasets, Tecnick (Asuni and Giachetti, 2014) and CLIC (2018). The original model fails to correctly decompress more than half of the images on average when compression and decompression occurs on different platforms. The modified model brings the failure rate down to $0 \\%$ in all cases. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a865c9ab4174bfbf3d830d1396893dbffeb412c482ec838ff0e3400b2afccbbb.jpg",
+        "image_caption": [
+            "Figure 4: Loss function across training of Ballé (2018) model, evaluated on Kodak (1993), corresponding to the rate point at approximately 0.7 bits per pixel in figure 3, right panel. Generally, training of integer models takes somewhat longer and is somewhat noisier than training of floating point models. When matching floating point and integer networks for asymptotic performance (128 vs. 256 filters, respectively), integer networks take longer to converge (likely due to their larger number of filters). When matching by number of filters (128), it appears that the training time to convergence is about the same, but the performance ends up worse. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            828,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            430,
+            825,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It should be noted that the decreased accuracy of integer arithmetic generally leads to a lower approximation capacity than with floating point networks. We found that when implementing the models described in Ballé (2018) using integer networks throughout, the rate–distortion performance decreased (figure 3, right). The loss in approximation capacity can be compensated for by increasing the number of filters per layer. Note that this appears to increase the training time necessary for convergence (figure 4). However, note that increasing the number of parameters may not necessarily increase the size of the model parameters or the runtime, as the storage requirements for integer parameters (kernels, biases, etc.) are lower than for floating point parameters, and integer arithmetic is computationally less complex than floating point arithmetic in general. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            733,
+            310,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There is a large body of recent research considering quantization of ANNs mostly targeted at image recognition applications. Courbariaux et al. (2015) train classification networks on lower precision multiplication. Hubara et al. (2016) and Rastegari et al. (2016) perform quantization down to bilevel (i.e., 1-bit integers) at inference time to reduce computation in classification networks. More recently, Wu et al. (2018) and others have used quantization during training as well as inference, to reduce computation on gradients as well as activations, and Baluja et al. (2018) use non-uniform quantization to remove floating point computation, replacing it completely with integer offsets into an integer lookup table. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the quantization of neural networks is not a new topic, the results from the above techniques focus almost exclusively on classification networks. Denton et al. (2014), Han et al. (2016), and others have demonstrated that these types of networks are particularly robust to capacity reduction. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Models used for image compression, like many generative models, are much more sensitive to capacity constraints since they tend to underfit. As illustrated in Ballé (2018) and in figure 3 (right), this class of models is much more sensitive to reductions of capacity, both in terms of network size and the expressive power of the activation function. This may explain why our experiments with post-hoc quantization of network activations have never yielded competitive results for this class of model (not shown). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in figure 1 and table 1, small floating point inconsistencies in variational latent-variable models can have disastrous effects when we use range coding to employ the models for data compression across different hardware or software platforms. The reader may wonder whether there exists other entropy coding algorithms that can convert discrete latent-variable representations into a binary representation, and which do not suffer from a sensitivity to perturbations in the probability model. Unfortunately, such an algorithm would always produce suboptimal results for the following reason. The source coding theorem (Shannon, 1948) establishes a lower bound on the average length of the resulting bit sequences, which range coding achieves asymptotically (i.e. for long bit sequences). The lower bound is given by the cross entropy between the marginal and the prior: ",
+        "bbox": [
+            173,
+            194,
+            825,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/786031a35590cd81be96ba2593d76313da6cd3b82795e6b00aa6db14c740d1e3.jpg",
+        "text": "$$\n\\mathbb { E } _ { { \\pmb { y } } \\sim m } [ | b ( { \\pmb { y } } ) | ] \\geq \\mathbb { E } _ { { \\pmb { y } } \\sim m } [ - \\log _ { 2 } p ( { \\pmb { y } } \\mid { \\pmb { \\theta } } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            323,
+            633,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $\\left| b ( \\boldsymbol { y } ) \\right|$ is the length of the binary representation of $\\textbf {  { y } }$ . If an entropy coding algorithm tolerates error in the values of $p ( \\pmb { y } \\mid \\pmb { \\theta } )$ , this means it must operate under the assumption of identical probability values for a range of values of $\\pmb { \\theta } -$ in other words, discretize the probability values. Since the cross entropy is minimal only for $p ( \\pmb { y } \\mid \\pmb { \\theta } ) = m ( \\pmb { y } )$ (for all $\\textbf {  { y } }$ ), this would impose a new lower bound on $\\left| b ( \\pmb { y } ) \\right|$ given by the cross entropy with the discretized probabilities, which is greater or equal to the cross entropy given above. Thus, the more tolerant the entropy coding method is to errors in $p$ , the further it deviates from optimal performance. Moreover, it is hard to establish tolerance intervals for probability values computed with floating point arithmetic, in particular when ANNs are used, due to error propagation. Hence, it is generally difficult to provide guarantees that a given tolerance will not be exceeded. For similar reasons, current commercial compression methods model probabilities exclusively in the discrete domain (e.g., using lookup tables; Marpe et al., 2003). ",
+        "bbox": [
+            173,
+            342,
+            825,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our approach to neural network quantization is the first we are aware of which specifically addresses non-deterministic computation, as opposed to computational complexity. It enables a variety of possible variational model architectures and distributions to be effectively used for platformindependent data compression. While we aren’t assessing its effects on computational complexity here, it is conceivable that complexity reductions can also be achieved with the same approach; this is a topic for future work. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            601,
+            285,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ágústsson, Eiríkur Þór et al. (2017). “Soft-to-Hard Vector Quantization for End-to-End Learning Compressible Representations”. In: Advances in Neural Information Processing Systems 30, pp. 1141–1151.   \nAlemi, Alexander A. et al. (2018). “Fixing a Broken ELBO”. In: arXiv e-prints. arXiv: 1711 . 00464.   \nAsuni, N. and A. Giachetti (2014). “TESTIMAGES: A large-scale archive for testing visual devices and basic image processing algorithms”. In: Proc. of STAG: Smart Tools and Apps for Graphics. DOI: 10.2312/stag.20141242.   \nBallé, Johannes (2018). “Efficient Nonlinear Transforms for Lossy Image Compression”. In: Picture Coding Symposium (PCS), 2018.   \nBallé, Johannes et al. (2018). “Variational image compression with a scale hyperprior”. In: Proc. of 6th Int. Conf. on Learning Representations. URL: https://openreview.net/forum? id $=$ rkcQFMZRb.   \nBaluja, Shumeet et al. (2018). “No Multiplication? No Floating Point? No Problem! Training Networks for Efficient Inference”. In: arXiv e-prints. arXiv: 1809.09244.   \nCLIC: Challenge on Learned Image Compression (2018). Mobile and Professional Datasets. URL: http://www.compression.cc/2018/challenge.   \nCourbariaux, Matthieu, Jean-Pierre David, and Yoshua Bengio (2015). “Training deep neural networks with low precision multiplications”. In: arXiv e-prints. Presented as a workshop contribution at the 3rd Int. Conf. on Learning Representations. arXiv: 1412.7024.   \nCover, Thomas M. and Joy A. Thomas (2006). Elements of Information Theory. 2nd ed. Wiley.   \nDenton, Emily et al. (2014). “Exploiting Linear Structure Within Convolutional Networks for Efficient Evaluation”. In: Advances in Neural Information Processing Systems 27, pp. 1269–1277.   \nHan, Song, Huizi Mao, and William J. Dally (2016). “Deep Compression: Compressing Deep Neural Network with Pruning, Trained Quantization and Huffman Coding”. In: arXiv e-prints. Presented at the 4th Int. Conf. on Learning Representations. arXiv: 1510.00149.   \nHiggins, Irina et al. (2017). “ $\\beta$ -VAE: Learning Basic Visual Concepts with a Constrained Variational Framework”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https : //openreview.net/forum?id $=$ Sy2fzU9gl.   \nHubara, Itay et al. (2016). “Binarized Neural Networks”. In: Advances in Neural Information Processing Systems 29, pp. 4107–4115.   \nJang, Eric, Shixiang Gu, and Ben Poole (2017). “Categorical Reparameterization with GumbelSoftmax”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https : / / openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rkE3y85ee.   \nKingma, Diederik P. and Max Welling (2014). “Auto-Encoding Variational Bayes”. In: arXiv eprints. Presented at the 2nd Int. Conf. on Learning Representations. arXiv: 1312.6114.   \nKlopp, Jan P. et al. (2018). “Learning a Code-Space Predictor by Exploiting Intra-ImageDependencies”. In: Proc. of 29th British Machine Vision Conference.   \nKodak, Eastman (1993). Kodak Lossless True Color Image Suite (PhotoCD PCD0992). URL: http://r0k.us/graphics/kodak/.   \nMarpe, Detlev, Heiko Schwarz, and Thomas Wiegand (2003). “Context-Based Adaptive Binary Arithmetic Coding in the H.264/AVC Video Compression Standard”. In: IEEE Transactions on Circuits and Systems for Video Technology 13.7. DOI: 10.1109/TCSVT.2003.815173.   \nMinnen, David, Johannes Ballé, and George Toderici (2018). “Joint Autoregressive and Hierarchical Priors for Learned Image Compression”. In: Advances in Neural Information Processing Systems 31, pp. 10771–10780.   \nOord, Aäron van den, Oriol Vinyals, and Koray Kavukcuoglu (2017). “Neural Discrete Representation Learning”. In: Advances in Neural Information Processing Systems 30, pp. 6306–6315.   \nRastegari, Mohammad et al. (2016). “XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks”. In: ECCV 2016. Lecture Notes in Computer Science. Vol. 9908. DOI: 10.1007/978-3-319-46493-0_32.   \nRissanen, Jorma and Glen G. Langdon Jr. (1981). “Universal modeling and coding”. In: IEEE Transactions on Information Theory 27.1. DOI: 10.1109/TIT.1981.1056282.   \nShannon, Claude E. (1948). “A Mathematical Theory of Communication”. In: The Bell System Technical Journal 27.3. DOI: 10.1002/j.1538-7305.1948.tb01338.x.   \nSønderby, Casper Kaae et al. (2016). “Ladder variational autoencoders”. In: Advances in Neural Information Processing Systems 29, pp. 3738–3746.   \nTheis, Lucas et al. (2017). “Lossy Image Compression with Compressive Autoencoders”. In: Proc. of 5th Int. Conf. on Learning Representations. URL: https://openreview.net/forum? id $=$ rJiNwv9gg.   \nWu, Shuang et al. (2018). “Training and Inference with Integers in Deep Neural Networks”. In: Proc. of 6th Int. Conf. on Learning Representations. URL: https://openreview.net/ forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HJGXzmspb. ",
+        "bbox": [
+            173,
+            631,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            95,
+            826,
+            691
+        ],
+        "page_idx": 9
+    }
+]

parse/train/oyZxhRI2RiE/oyZxhRI2RiE.md

@@ -0,0 +1,417 @@
+# SCORE: PRE-TRAINING FOR CONTEXT REPRESENTATION IN CONVERSATIONAL SEMANTIC PARSING
+
+Tao Yu Yale University tao.yu@yale.edu
+
+Rui Zhang The Pennsylvania State University rmz5227@psu.edu
+
+Oleksandr Polozov, Christopher Meek, Ahmed Hassan Awadallah Microsoft Research {polozov,meek,hassanam}@microsoft.com
+
+# ABSTRACT
+
+Conversational Semantic Parsing (CSP) is the task of converting a sequence of natural language queries to formal language (e.g., SQL, SPARQL) that can be executed against a structured ontology (e.g. databases, knowledge bases). To accomplish this task, a CSP system needs to model the relation between the unstructured language utterance and the structured ontology while representing the multi-turn dynamics of the dialog. Pre-trained language models (LMs) are the state-of-the-art for various natural language processing tasks. However, existing pre-trained LMs that use language modeling training objectives over free-form text have limited ability to represent natural language references to contextual structural data. In this work, we present SCORE, a new pre-training approach for CSP tasks designed to induce representations that capture the alignment between the dialogue flow and the structural context. We demonstrate the broad applicability of SCORE to CSP tasks by combining SCORE with strong base systems on four different tasks (SPARC, COSQL, MWOZ, and SQA). We show that SCORE can improve the performance over all these base systems by a significant margin and achieves state-of-the-art results on three of them.
+
+# 1 INTRODUCTION
+
+The goal of task-oriented dialog systems is to assist the user in completing a certain task by performing an action or retrieving relevant information (Tur & Mori, 2011). They are often built on top of a structured ontology grounded in a knowledge base, a database, or a set of API calls. This in contrast to open-domain dialog systems (also referred to as chit-chat systems) where the goal is to maximize engagement with users in open-ended conversations (Jafarpour et al., 2010; Ritter et al., 2011).
+
+A key component of task-oriented conversational systems is Conversational Semantic Parsing (CSP), which converts each utterance in the dialog into a formal language query (e.g., SQL, SPARQL) that can be executed against the structured ontology. CSP has been extensively studied in several academic and industrial research settings such as dialog systems (e.g., dialog state tracking in MWOZ (Budzianowski et al., 2018)), interacting with physical agents (e.g., (Chai et al., 2018)), context-dependent semantic parsing (e.g., SPARC (Yu et al., 2019b)), SQL-grounded state tracking (e.g., COSQL (Yu et al., 2019a)), and sequential question answering (e.g., SQA (Iyyer et al., 2017)). These settings differ in some respect, but they share the same overall objective and key challenge: how to jointly represent the natural language utterances and underlying structured ontology while taking into consideration the multi-turn dynamics of the dialog.
+
+Similar to many other natural language tasks, recent work in CSP has significantly benefited from advances in language model pre-training. However, existing general-purpose pre-trained language models, e.g. BERT (Devlin et al., 2019), are pre-trained on free-form text data using language model objectives. This limits their ability in modeling the structural context or the multi-turn dynamics of the dialogs. This presents an opportunity to improve pre-trained LMs to specifically address these limitations for CSP tasks. Recent work has demonstrated the benefits of adapting pre-trained LMs to specific domains (Gururangan et al., 2020) or tasks (Zhang et al., 2019b) via a second phase of pre-training. For example, open-domain dialogue language models such as DialoGPT (Zhang et al., 2020) and ConveRT (Henderson et al., 2019) are pre-trained on the Reddit data and applied to dialog response generation and retrieval tasks.
+
+![](images/7aee0dcf05f327f0a25d0a1d95fd1e53bd5c59396766fe11cc27b236f4dec59f.jpg)  
+Figure 1: Examples of conversational semantic parsing tasks from SPARC and MWOZ datasets.
+
+In this paper, we introduce SCORE (Structured & Sequential Context Representation), a language model pre-training approach for CSP tasks. SCORE adapts general pre-trained LMs by introducing a second phase of pre-training using multiple objectives that capture both multi-turn dynamics and the structural contexts in a dialog. In contrast to open-domain dialogs, CSP datasets are usually much smaller due to the difficulty and expense of obtaining and labeling data (mapping natural language utterances to formal language). Unlike most prior work on contextualized LMs which are pre-trained on free text, according to the finding where questions in CSP tasks are more compositional than other free-text since they can be mapped into formal representations, we propose to train SCORE on synthesized conversational semantic parsing data with multiple training objectives that aim to ground utterances into the schema of the underlying ontology and to model the relationship between different utterances in the multi-turn conversation. In this way, SCORE can effectively inject structural and conversational inductive biases in LMs that can translate to many CSP tasks. SCORE uses an order of magnitude smaller dataset for the second stage of pre-training, does not require changes to the pre-trained model architecture, can be used as a drop-in replacement of general pre-trained LMs with any semantic parsing model, and can be used out-of-the-box in many CSP tasks.
+
+We apply SCORE to four different CSP tasks: (1) sequential text-to-SQL (SPARC), (2) conversational text-to-SQL (COSQL), (3) dialog state tracking (MWOZ), and (4) weakly-supervised sequential question answering (SQA). The fours tasks represent different scenarios, types of ontologies, supervision signals, system responses, and domains (see Table 1 for a detailed comparison and Figure 1 for examples). We demonstrate that: (1) SCORE training objectives can effectively incorporate synthesized data, (2) a single pre-trained SCORE model can be used for several CSP tasks and can be combined with many baseline systems with different model architectures and (3) SCORE significantly improve all baseline systems and achieves new state-of-the-art results on three benchmarks (SPARC, SPARC, and MWOZ) and comparable performance to state-of-the-art results on the fourth (SQA).
+
+# 2 APPROACH
+
+The key challenge of CSP is to capture the relationship between the natural language utterance and the structured ontology in the multi-turn dialog dynamics. To this end, we inject structural and conversational inductive biases in SCORE by introducing two objective functions: Column Contextual Semantics (CCS) and the Turn Contextual Switch (TCS). Because the size of existing semantic parsing datasets is limited, we produce synthesized data for pretraining SCORE by sampling from the context-free grammar induced from complex text-to-SQL examples in different domains. Moreover, to prevent SCORE from overfitting to the linguistic pattern of our synthesized data, we use the Masked Language Modeling (MLM) objective on human-generated utterances as regularization.
+
+# 2.1 PRELIMINARIES
+
+Task Definition In CSP, at each turn $t$ , we aim to produce a formal representation $q _ { t }$ given the current utterance $u _ { t }$ , the interaction history $h _ { t } = [ u _ { 1 } , u _ { 2 } , \ldots , u _ { t - 1 } ]$ , and the schema $c$ (table and column names, slots, etc.) of the target database (ontology) $d$ . To cover different problem variants, we
+
+<table><tr><td>Dataset</td><td>Structured Ontology</td><td>Annotation (Supervision)</td><td>Cross Domain</td><td>System Response</td><td># Dialogs</td><td># Turns</td></tr><tr><td>SPARC</td><td>database</td><td>SQL (supervised)</td><td>√</td><td>X</td><td>4,298</td><td>12,726</td></tr><tr><td>CoSQL</td><td>database</td><td>SQL (supervised)</td><td>√</td><td>√</td><td>3,007</td><td>15,598</td></tr><tr><td>MWoZ</td><td>domain ontology</td><td>slot-value (supervised)</td><td>X</td><td>√</td><td>8,438</td><td>113,556</td></tr><tr><td>SQA</td><td>table</td><td>denotation (weakly-supervised)</td><td>√</td><td>X</td><td>6,066</td><td>17,553</td></tr></table>
+
+Table 1: Comparison of CSP datasets. Examples from two of the datasets are shown in Figure 1.   
+Cross-domain means the train and test sets have different domains, so MWOZ is not cross-domain.
+
+consider four popular CSP tasks shown in Table 1: SPARC (sequential text-to-SQL), COSQL (conversational text-to-SQL), MWOZ (dialogue state tracking), and SQA (weakly supervised sequential question answering). They have different target formal language and structured ontology:
+
+• For the utterance $\textbf { \em u }$ , it is the user question for SPARC and SQA, while for COSQL and MWOZ, $u$ is the combination of a user query and a system response.   
+• For the database $^ d$ , SPARC and COSQL use multi-table databases; for MWOZ, the pre-defined ontology $d$ can also be viewed as a database; for SQA, $d$ is a single table.   
+• For the formal representation $\pmb q$ , it is the SQL query for SPARC and COSQL; in MWOZ it is the slot-value pairs that can be viewed as simple SQL queries consisting of SELECT and WHERE clauses; and for SQA, $q$ is the latent program.
+
+Base Architecture The base architecture of SCORE takes as input a single turn of a CSP dialog $\left. u _ { t } , h _ { t } \right.$ jointly with the underlying database schema $c$ . Given this contextualized conversational input $C _ { t } = \langle u _ { t } , h _ { t } , c \rangle$ , SCORE encodes it into contextualized conversation representations $\vec { S } _ { t }$ for each token in $C _ { t }$ . The encoder architecture follows RoBERTa (Liu et al., 2019b). It is then followed by a linear layer and normalized (Ba et al., 2016) to produce final representations $\vec { h } _ { t }$ for each token:
+
+$$
+C _ { t } = \langle u _ { t } , h _ { t } , c \rangle , \ \vec { S } _ { t } = \mathrm { R o B E R T A } ( C _ { t } ) , \ h _ { t , i } = \mathrm { L a y e r N o r m } ( \mathrm { G E L U } ( W _ { 1 } S _ { t , i } ) ) \ \forall S _ { t , i } \in \vec { S } _ { t } ,
+$$
+
+where GELU is an activation by Hendrycks & Gimpel (2016) and $W _ { 1 }$ is a learned parameter matrix.
+
+To build $C _ { t }$ , we first concatenate current utterances $u _ { t }$ and dialog history $h _ { t }$ separated by a special token $< s >$ , as this simple strategy has been shown effective in state-of-the-art CSP systems (Zhang et al., $2 0 1 9 \mathrm { c }$ ; Wu et al., 2019; Liu et al., 2020; Heck et al., 2020). To incorporate the database schema, we follow Hwang et al. (2019) to concatenate all column names as a single sequence. Column names are separated by the special token $< / \varsigma >$ and prefixed by their corresponding table name.
+
+# 2.2 SCORE PRE-TRAINING
+
+SCORE addresses the challenges of CSP by pre-training a task-oriented language model contextualized by the conversational flow and the underlying ontology. In pre-training, the SCORE model is self-supervised by two novel objectives in addition to the established Masked Language Modeling (MLM) objective. These objectives facilitate the accurate representation of the conversational flow between dialog turns and how this flow maps to the desired columns in the ontology.
+
+Column Contextual Semantics The first challenge of CSP is capturing the alignment between the natural language utterance and the underlying database schema. To address it, we optimize the SCORE model with the auxiliary objective of Column Contextual Semantics (CCS). For each column in the database schema $c$ , CCS targets the operations that should be performed on this column in a given conversational turn. Specifically, each formal representation $q$ is decomposed into operations on columns and tables, e.g. GROUP BY and HAVING for SQL queries, or WHERE for the slot-value pairs. In this way, our data covers 148 column operations. We use the encoding of the special token $< / \varsigma >$ right before each column or table name to predict its corresponding operations, and then compute the CCS loss:
+
+$$
+{ \mathcal { L } } _ { \mathrm { C C S } } ( C _ { t } ) = \sum _ { i \in c } { \mathrm { C r o s s E n t r o p y } } _ { 1 4 8 } ( { \mathrm { L a y e r N o r m } } ( W _ { 2 } h _ { t , i } ^ { c } ) , { \mathrm { C C S } } ( q _ { t } ) )
+$$
+
+where $h _ { t , i } ^ { c }$ is the contextualized representation of the $i ^ { \mathrm { { t h } } }$ column’s special token $< / \varsigma >$ in the contextualized input $C _ { t }$ , $\operatorname { C C S } ( q _ { t } )$ returns the column operation label for the current formal representation $q _ { t }$ , CrossEntropy $^ { 1 4 8 }$ computes the 148-way cross-entropy between the column operation prediction and label, and $W _ { 2 }$ is a learned parameter matrix.
+
+![](images/a26fd1e21b056c19bb034c1f12fdaf1d1a572af164e6b8ac9602885a9dd040ef.jpg)  
+Dialogs Formal Programs DatabaseFigure 2: Pre-training of a SCORE encoder on a SPARC text-to-SQL example from Figure 1.
+
+Usr: Also show the names of their publishers. SELECT t1.title, t1.name, t3.name FROM author AS t1 JOIN book  Book: id | title | author id | … | sale_amountTurn Contextual Switch The second challenge of CSP is capturing the conversational context t3.id ORDER BY t2.sale_amount DESC LIMIT 3flow and how it is grounded into the formal representations. The TCS objective aims to capture this Usr: I am looking for a cheap restaurant in the  Restaurant(Price=cheap, area=center)grounding of context flow. To this end, it targets predicting the difference in formal representations Sys: There is a cheap chinese restaurant called between dialog turns based on the natural language utterance.
+
+… ...  Taxi: leaveAt | … | destinationBased on the context-free grammar of SQL, we identify 26 possible turn difference operations that a Usr: I also need to book a taxi between to the restaurant at 20:30. Restaurant(price=cheap, area=center, name=Dojo Noodle Bar, people=8, time=18:30, day=Thursday)conversational turn could elicit. They encode changes between different turns of user queries (the sysSys: The taxi is booked. tem response is not involved here) since we assume that most turn contextual shifts are from the user. For example, INS(WHERE) indicates inserting a new WHERE condition and DEL(SELECT.agg) indicates removing an aggregate operation from a SELECT statement (e.g. when an utterance “Show all the ages instead.” elicits a change SELECT MAX(age) ... SELECT age ...). We use the encoding of the special token $< / \varsigma >$ right before each turn to predict the context switch label between this turn and the previous history:
+
+$$
+\mathcal { L } _ { \mathrm { T C S } } ( C _ { t } ) = \mathrm { C r o s s E n t r o p y } _ { 2 6 } ( \mathrm { L a y e r N o r m } ( W _ { 3 } H _ { t } ^ { s } ) , \mathrm { T C S } ( q _ { t } , q _ { t - 1 } ) )
+$$
+
+where $\pmb { H } _ { t } ^ { s } \in \mathbb { R } ^ { ( t - 1 ) \times d }$ is the contextualized representation of all previous turns in $C _ { t }$ with hidden dimension $d$ , $\mathrm { T C S } ( q _ { t } , q _ { t - 1 } )$ returns the turn difference operations from $q _ { t - 1 }$ to $q _ { t }$ , and $W _ { 3 }$ is a learned parameter matrix. We don’t use this objective to pre-train SCORE for MWOZ because the context switch label between turns is relatively simple in MWOZ (only select and where changes).
+
+Masked Language Modeling As in prior work on large-scale language models (Devlin et al., 2019), we use the Masked Language Modeling (MLM) objective to facilitate contextual representation learning for natural language utterances. Importantly for regularization, we only apply this loss on in-domain human-annotated natural language data. Namely, it includes utterances in SPARC, COSQL, and SQA as well as nine task-oriented dialog datasets processed by Wu et al. (2020) for MWOZ (see data statistics in Figure 4). Formally, the MLM loss is given by:
+
+$$
+\mathcal { L } _ { \mathrm { M L M } } ( C _ { t } ) = \sum _ { m } \mathrm { C r o s s E n t r o p y } _ { \mathrm { V o c a b } } ( \mathrm { L a y e r N o r m } ( W _ { 4 } h _ { t } ^ { m } ) )
+$$
+
+where $\pmb { h } _ { t } ^ { m }$ are the contextualized representations of the masked $15 \%$ of tokens in $C _ { t }$ , and $W _ { 4 }$ is a learned parameter matrix.
+
+Pre-Training Setup and Steps To summarize the pre-training steps, we first collect a dataset $\mathcal { D } _ { \mathrm { n a t } }$ of combined human-annotated natural language questions (without labels) from existing CSP tasks (as mentioned above), and create a large synthesized conversational data $\mathcal { D } _ { \mathrm { s y n } }$ that is generated by a grammar induced from a small set of SPARC annotated examples (See 2.3). After that, we incorporate both two datasets in pre-training. More specifically, synthetic and natural examples are randomly sampled during pre-training. The total pre-training loss is the sum of the three objectives with CCS and TCS only applied to $\mathcal { D } _ { \mathrm { s y n } }$ and MLM only to $\mathcal { D } _ { \mathrm { n a t } }$ :
+
+$$
+\mathcal { L } = \sum _ { C _ { t } \in \mathcal { D } _ { \mathrm { s y n } } } \left( \mathcal { L } _ { \mathrm { C C S } } ( C _ { t } ) + \mathcal { L } _ { \mathrm { T C S } } ( C _ { t } ) \right) + \sum _ { C _ { t } \in \mathcal { D } _ { \mathrm { n a t } } } \mathcal { L } _ { \mathrm { M L M } } ( C _ { t } )
+$$
+
+Figure 2 shows an overview of SCORE pre-training on an example SPARC dialogue from Figure 1.   
+We report additional implementation details for pre-training SCORE in Section 3.3 and Appendix C.
+
+# 2.3 DATA SYNTHESIS
+
+We re-use the synthetic dataset of 120k synthetic task-oriented dialogues for MWOZ, introduced by Campagna et al. (2020). In this work, we introduce a complementary procedure to synthesize data for conversational text-to-SQL dialogues. We use about $4 0 0 \mathrm { k }$ tables in WIKITABLES (Bhagavatula et al., 2015) (after filtering and cleaning), WikiSQL, and Spider datasets as underlying databases $d$ , and then synthesize about one dialog for each table. Finally, we synthesize $4 3 5 \mathrm { k }$ text-to-SQL conversations in total. Table 12 in Appendix B shows an example of the synthesized question-SQL pairs and their corresponding templates in our grammar.
+
+To this end, we use only 500 dev examples from SPARC to induce two utteranceSQL generation grammars: (1) a singleturn context-free grammar $G _ { s }$ for generating context-independent question-SQL pairs, and (2) a follow-up context-free grammar $G _ { c }$ for follow-up question-SQL pairs. The single-turn grammar $G _ { s }$ contains a list of synchronous question-SQL templates where typed slots (COLUMN0, OP0, VALUE0, . . . ) represent mentions of tables, columns, values, and SQL operations. The follow-up grammar $G _ { c }$ contains context switch labels and lists of follow-up question templates. For example, if the context switch label is INS(SELECT.column0), the corresponding question could be “How about show column0 too?”. To ensure generalization, we only induce the grammars from the SPARC training set. Appendix B shows examples of the grammar rules and synthesized utterances.
+
+# Algorithm 1 Data synthesis algorithm
+
+1: $\tilde { h }  \emptyset$   
+2: $r _ { s } \gets \mathbf { S A M P L E } ( G _ { s } )$   
+3: $\tilde { u } _ { 0 } , \tilde { q } _ { 0 } \gets$ RANDASSIGNSLOTS(d, rs)   
+4: $\tilde { h } + = ( \tilde { u } _ { 0 } , \tilde { q } _ { 0 } )$   
+5: $\tilde { u } _ { p } , \tilde { q } _ { p } \gets \tilde { u } _ { 0 } , \tilde { q } _ { 0 }$   
+6: for $t \gets 1$ to $T$ do   
+7: if $\mathrm { R A N D } ( 0 , 1 ) < 0 . 2$ then   
+8: $r _ { s } \gets \mathbf { S A M P L E } ( G _ { s } )$   
+9: $\tilde { u } _ { t } , \tilde { q } _ { t } \gets \mathrm { R A N D A S S I G N S L O T S } ( d , r _ { s } )$   
+10: else   
+11: $r _ { c } \gets \mathbf { S A M P L E } ( G _ { c } )$   
+12: if CONSTRAINTCHECK $( r _ { c } , \tilde { q } _ { p } )$ then   
+13: u˜t, q˜t ← EDITASSIGN(˜qp, rc)   
+14: h˜+ = (˜ut, q˜t, rc)   
+15: u˜p, q˜p ← u˜t, q˜t   
+16: return h˜
+
+The data synthesis procedure using the two grammars is shown in Algorithm 1. Given a database $d$ and a sampled single-turn question-SQL template, the function RANDASSIGNSLOTS samples values (column names, cell values, and SQL operations) for typed slots in the template and returns the first synthesized question $\tilde { u } _ { 0 }$ and the corresponding SQL query $\tilde { q } _ { 0 }$ . To generate $T$ follow-up question-SQL pairs, the function CONSTRAINTCHECK $( r _ { c } , \tilde { q } _ { p } )$ checks if the previous query $\tilde { q } _ { p }$ satisfies constraints of the sampled template $r _ { c }$ (e.g. contains its mentioned nonterminal). Finally, EDITASSIGN $( \tilde { q } _ { p } , r _ { c } )$ edits the previous SQL $\tilde { q } _ { p }$ to generate the current follow-up SQL label $\tilde { q } _ { t }$ and samples values for typed slots in the template to generate the corresponding follow-up question $\tilde { u } _ { t }$ .
+
+# 3 EXPERIMENT SETTINGS
+
+# 3.1 DATASETS AND EVALUATION METRICS
+
+We evaluate SCORE on four popular CSP tasks: SPARC (sequential text-to-SQL), COSQL (conversational text-to-SQL), MWOZ (dialogue state tracking), and SQA (sequential question answering), summarized in Table 1.
+
+SPARC (Yu et al., 2019b) 1 is a large collection of sequences of inter-related context-dependent question-SQL pairs. It contains 4.3K questions sequences and $1 2 \mathrm { k } +$ questions. COSQL (Yu et al., 2019a) 2 is a large conversational text-to-SQL corpus, with 3k dialogues, collected under the Wizardof-Oz (WOZ) setting. We focus on the SQL-grounded dialogue state tracking task which maps user intents into SQL queries if possible given the interaction history. Both SPARC and COSQL cover 200 complex DBs spanning 138 domains.
+
+MWOZ (Budzianowski et al., 2018; Eric et al., 2019) 3 is a corpus of over 10k human-human written task-oriented dialogs created through a WOZ crowdsourcing setting. We focus on the belief state tracking task in MWOZ which maps multi-turn user utterances to slot-value annotations.
+
+SQA (Iyyer et al., 2017) 4 is constructed from a subset of WikiTableQuestions (Pasupat & Liang, 2015) by decomposing highly compositional questions into a sequence of simple questions. The task is weakly-supervised because each resulting decomposed question is only annotated with answers as one or more table cells, while the logic program is latent. It has 6,066 question sequences with 17,553 questions in total on 982 unique open-domain tables from Wikipedia.
+
+We adopt the official metrics defined for each of the tasks. For SPARC and COSQL, we report question match accuracy (QM): the exact set match accuracy (Yu et al., 2018b) over SQL templates and interaction match accuracy (IM): the ratio of interactions for which all questions are predicted correctly. For MWOZ, we report joint goal accuracy (JGA) which is similar to the IM accuracy used in SPARC and COSQL. Finally, for SQA, we report denotation QM and IM accuracies.
+
+# 3.2 BASE MODELS AND OTHER BASELINES
+
+For SPARC and COSQL, we use RAT-SQL (Wang et al., 2020) as our base model. Since it is originally developed for single-turn text-to-SQL, we extend it to a multi-turn setting by concatenating current utterances and dialog history (see Section 2.2). Note that RAT-SQL alone, without SCORE, achieves better or comparable results to state-of-the-art models developed for SPARC and COSQL.
+
+For MWOZ, we employ Trippy (Heck et al., 2020). It achieves state-of-the-art performance on MWOZ and uses $\mathbf { B E R T _ { b a s e } }$ to encode user and system utterances and dialog history. We report higher results (around $2 \%$ ) for Trippy than reported by Heck et al. (2020) since we train it for more epochs (25 vs. 10). To show the improvement of SCORE is not tied to specific base systems, we also experiment with another strong base model SOM-DST (Kim et al., 2020) for MWOZ and follow the same experimental details to train it.
+
+For SQA, we use the weakly-supervised semantic parser proposed by Wang et al. (2019). The model first generates an abstract program given an input question and then instantiates it by searching for alignments between slots in the abstract program and question spans. As it is originally developed for single-turn questions, we extend it to the multi-turn setting in the same way as RAT-SQL.
+
+We report additional implementation details for all base models in Appendix C. In addition to reporting results for all base models with SCORE, we also report original base models results (with BERT and/or ROBERTA) and several other state-of-the-art baselines for each task.
+
+# 3.3 DATASET USAGE IN PRE-TRAINING
+
+In our experiments and ablation study, we train several versions of SCORE with different objectives and datasets: (1) SCORE (MLM): pre-trained on annotated natural questions using MLM. (2) SCORE $( \mathrm { C C S + T C S } )$ ): pre-trained on only synthesized data, which achieves the best results on SParC, CoSQL, and SQA. (3) SCORE $\mathbf { C C S + T C S + M L M } )$ : pre-trained on the synthesized data using $\mathrm { C C S + T C S }$ and annotated natural questions using MLM.
+
+Furthermore, note that the synthesized data is generated using grammar induced by about 500 examples from only SPARC. Therefore, no COSQL or SQA data are seen in any pre-training steps. For MWOZ, Campagna et al. (2020) study only the dev examples to induce the data synthesis grammar.
+
+# 4 RESULTS AND ANALYSIS
+
+Overall Results The results of SPARC and COSQL, MWOZ, and SQA are in Table 2, 3, and 4 respectively. We run each main experiment three times with different random seeds and report the mean. Overall, SCORE gains significant improvements over BERT and ROBERTA on all tasks, achieving state-of-the-art performances on SPARC, COSQL, and MWOZ.
+
+Table 2: The SPARC and COSQL accuracy over all questions (QM) and all interactions (IM). The scores of IGSQL $^ +$ BERT and $\mathrm { R ^ { 2 } S Q L + }$ BERT are from the official leaderboards.   
+
+<table><tr><td rowspan="3"></td><td colspan="4">SPARC</td><td colspan="4">CoSQL</td></tr><tr><td colspan="2">Dev</td><td colspan="2">Test</td><td colspan="2">Dev</td><td colspan="2">Test</td></tr><tr><td>QM</td><td>IM</td><td>QM</td><td>IM</td><td>QM</td><td>IM</td><td>QM</td><td>IM</td></tr><tr><td>SyntaxSQL (Yu et al.,2018a)</td><td>18.5</td><td>4.3</td><td>20.2</td><td>5.2</td><td>1</td><td>-</td><td>14.2</td><td>2.2</td></tr><tr><td>GAZP + BERT (Zhong et al., 2020)</td><td>48.9</td><td>29.7</td><td>45.9</td><td>23.5</td><td>42.0</td><td>12.3</td><td>39.7</td><td>12.8</td></tr><tr><td>EditSQL + BERT (Zhang et al.,2019c)</td><td>47.2</td><td>29.5</td><td>47.9</td><td>25.3</td><td>39.9</td><td>12.3</td><td>40.8</td><td>13.7</td></tr><tr><td>IGSQL +BERT</td><td>50.7</td><td>32.5</td><td>51.2</td><td>29.5</td><td>44.1</td><td>15.8</td><td>42.5</td><td>15.0</td></tr><tr><td>R²SQL +BERT</td><td>1</td><td>-</td><td>55.8</td><td>30.8</td><td>1</td><td>-</td><td>46.8</td><td>17.0</td></tr><tr><td>RAT-SQL + BERT (Wang et al., 2019)</td><td>56.8</td><td>33.4</td><td>1</td><td>1</td><td>48.4</td><td>19.1</td><td>1</td><td>-</td></tr><tr><td>+ROBERTA</td><td>58.2</td><td>36.7</td><td>-</td><td>-</td><td>50.1</td><td>19.3</td><td>-</td><td>-</td></tr><tr><td>+ SCoRE</td><td>62.2</td><td>42.5</td><td>62.4</td><td>38.1</td><td>52.1</td><td>22.0</td><td>51.6</td><td>21.2</td></tr></table>
+
+Table 3: Joint goal accuracies (JGA) on MWOZ 2.1 test set. All models use a BERT-like encoder/GPT.   
+
+<table><tr><td>Models</td><td>MWoZ 2.1</td></tr><tr><td>DST-reader (Gao et al.,2019)</td><td>36.40</td></tr><tr><td>TRADE (Wu et al., 2019)</td><td>46.60</td></tr><tr><td>DS-DST (Zhang et al.,2019a)</td><td>51.21</td></tr><tr><td>SOM-DST (Kim et al.,2020)</td><td>52.57</td></tr><tr><td>DS-picklist (Zhang et al.,2019a)</td><td>53.30</td></tr><tr><td>TripPy (Heck et al.,2020)</td><td>55.29</td></tr><tr><td>SimpleToD (Hosseini-Asl et al.,2020)</td><td>55.72</td></tr><tr><td>TripPy (ours)</td><td>58.37</td></tr><tr><td>+ SCoRE</td><td>60.48</td></tr></table>
+
+Table 4: Question (QM) and interaction (IM) accuracy on the SQA test set.   
+
+<table><tr><td rowspan="2">Models</td><td colspan="2">SQA</td></tr><tr><td>QM</td><td>IM</td></tr><tr><td>Pasupat &amp; Liang (2015)</td><td>33.2</td><td>7.7</td></tr><tr><td>Neelakantan et al. (2017)</td><td>40.2</td><td>11.8</td></tr><tr><td>Iyyer et al. (2017)</td><td>44.7</td><td>12.8</td></tr><tr><td>Sun et al. (2019a)</td><td>45.6</td><td>13.2</td></tr><tr><td>Muller et al. (2019)</td><td>55.1</td><td>28.1</td></tr><tr><td>Herzig et al. (2020)</td><td>67.2</td><td>40.4</td></tr><tr><td>Wang et al. (2019)+RoBERTa</td><td>62.8</td><td>33.2</td></tr><tr><td>Wang et al. (2019) + SCoRE</td><td>65.4</td><td>38.5</td></tr></table>
+
+For SPARC and $\mathrm { C o S Q L }$ in Table 2, compared with ROBERTA, SCORE boosts the performance by $4 . 0 \%$ QM / $5 . 8 \%$ IM on SPARC, and $2 . 0 \%$ QM / $2 . 7 \%$ IM on COSQL. This demonstrates the effectiveness of SCORE on contextual semantic parsing tasks. In addition, on MWOZ dialog state tracking task in Table 3, TripPy achieves $6 0 . 5 \%$ JGA by replacing BERT with SCORE, outperforming the prior state-of-the-art (Hosseini-Asl et al., 2020) by $4 . 8 \%$ . This indicates that dialog state tracking also benefits from SCORE. Finally, SCORE also achieves higher performance than ROBERTA on weakly supervised sequential question answering SQA task. As Table 4 shows, SCORE improves QM by $2 . 6 \%$ and IM by $4 . 9 \%$ over ROBERTA with Wang et al. (2019) as the base model. This demonstrates that the enhanced ability of semantic parsing and context modeling in SCORE is transferable to denotation-based CSP tasks.
+
+What is the effect of each pretraining objective? Table 5 shows an ablation study on different pretraining objectives. We find that the best SCORE results are achieved by pre-training on only synthesized data $( \mathrm { C C S + T C S } )$ ) without any natural questions (MLM) on SPARC,
+
+<table><tr><td>Learning Objective</td><td>SPARC</td><td>CoSQL</td><td>MWoZ</td><td>SQA</td></tr><tr><td>MLM only</td><td>37.0(+0.3)</td><td>20.3(+1.0)</td><td>59.47(+1.10)</td><td>34.7(+1.5)</td></tr><tr><td>CCS only</td><td>41.3(+4.6)</td><td>21.2(+1.9)</td><td>59.32(+0.95)</td><td>32.7(-0.5)</td></tr><tr><td>CCS+TCS</td><td>42.5(+5.8)</td><td>22.0(+2.7)</td><td></td><td>38.5(+5.3)</td></tr><tr><td>CCS+TCS+MLM</td><td>38.6(+1.9)</td><td>21.7(+2.4)</td><td>60.48(+2.11)</td><td>33.7(+0.5)</td></tr></table>
+
+Table 5: The effect of SCORE pre-training objectives. Improvements are shown in the parentheses.
+
+COSQL, and SQA but not on MWOZ. By adding MLM to $\mathrm { C C S + T C S }$ $\mathrm { C C S + T C S }$ vs. $\mathbf { C C S + T C S + M L M }$ ), MLM actually hurts the performance $- 3 . 9 \%$ on SParC, - $. 0 . 3 \%$ on $\mathbf { C o S Q L }$ , and $- 4 . 4 \%$ on SQA) while increases for MWOZ. One possible reason is that questions in MWOZ are more diverse in language but less compositional while semantic compositionality and turn changes are more important in the other three CSP tasks. Also, the synthesized data used to pre-train SCORE for SPARC and COSQL is generated by the grammar induced by SPARC, which might overfit to SPARC. In addition, SCORE pre-trained with only MLM loss improves the performance $( \ 1 . 0 \% )$ but not as large as $\mathrm { C C S + T C S }$ $( + 5 . 5 \%$ on SPARC, $+ 1 . 7 \%$ on COSQL, and $+ 3 . 4 \%$ on SQA). Finally, we test the effectiveness of TCS on SPARC, COSQL, and SQA by adding TCS to CCS (CCS only vs.
+
+CCS+TCS), SCORE gains improvements of $1 . 2 \%$ on SPARC and $0 . 8 \%$ on COSQL, and $4 . 4 \%$ on SQA.
+
+Does SCORE improve question match accuracy on individual turns? Table 6 shows detailed results of SCORE’s question accuracy for individual conversation turns on the SPARC dev set. SCORE provides a significant improvement for every conversation turn except the first (in which the task is more similar to single-turn
+
+<table><tr><td></td><td>QM</td><td>Q1</td><td>Q2</td><td>Q3</td><td>Q4</td></tr><tr><td>RAT-SQL +BERT</td><td>56.8</td><td>71.1</td><td>53.6</td><td>47.8</td><td>31.8</td></tr><tr><td>+RoBERTa</td><td>58.2</td><td>68.7</td><td>58.5</td><td>48.9</td><td>35.2</td></tr><tr><td>+ SCoRE</td><td>62.2</td><td>70.6</td><td>63.5</td><td>52.6</td><td>45.5</td></tr></table>
+
+Table 6: Detailed results on the dev set of SPARC.   
+$\mathrm { Q } _ { i }$ is the accuracy of the $i ^ { \mathrm { { t h } } }$ conversation question.
+
+semantic parsing). COSQL and SQA exhibit similar behavior and are presented in Appendix A.
+
+<table><tr><td></td><td>CoSQL</td><td>MWoZ</td></tr><tr><td>no syn</td><td>48.4</td><td>58.37</td></tr><tr><td>with syn</td><td>48.6</td><td>58.45</td></tr></table>
+
+What if we use the synthesized data to simply augment the training data? To answer this, we compare the results of the base models trained with or without the synthesized data on COSQL and MWOZ. As shown in Table 7, the extra synthetic data does not significantly improve the performance, indicating that directly augmenting the synthetic data to the training set is
+
+Table 7: Effect of synthetic data as training data augmentation.
+
+not effective. The similar findings are reported in many recent work (Zhang et al., $2 0 1 9 \mathrm { c }$ ; Herzig et al., 2020; Campagna et al., 2020; Zhong et al., 2020). In contrast, pre-training on the synthesized data with our objectives improves the performance on the downstream tasks.
+
+How general is SCORE and its synthetic grammar? For generalization in task settings, we have shown that the pre-training strategy of SCORE can improve the performance over different CSP tasks including semantic parsing (SPARC and COSQL), dialog state tracking (MWOZ), and weakly supervised table question answering (SQA). In addition, we demonstrate the effectiveness of SCORE on different base models. To this end, we experiment with a different base model SOM-DST for MWOZ. As shown in Table 8, SCORE can still improve the performance with a different base model on MWOZ (SOM-DST $+$ BERT vs. SOM-DST $+ \mathsfit { S }$ CORE on syn. MWOZ).
+
+<table><tr><td></td><td>MWoZ</td></tr><tr><td>SOM-DST+BERT</td><td>52.57</td></tr><tr><td>+ SCoRE on syn. text-to-SQL</td><td>53.57</td></tr><tr><td>+ SCoRE on syn. MWoZ</td><td>54.61</td></tr></table>
+
+Table 8: Performance of SCORE pre-trained on different synthesized data on MWOZ.
+
+To demonstrate the generalization in synthetic grammar and data, as shown in Table 2 and 4, SCORE $\mathrm { ( T C S + C C S ) }$ is pre-trained on the synthesized data of the grammar induced from SPARC only, and it still improves the performance on COSQL $( + 2 . 7 \% )$ and SQA $( + 4 . 9 \% )$ where no any CoSQL and SQA annotated data is seen in any pre-training steps. Moreover, in Table 8 we show that SCORE pre-trained on the text-to-SQL synthesized data could also surprisingly improve the performance on MWOZ. We expect that higher performance could be achieved with SCORE pre-trained on task-specific synthesized data. Finally, our pre-training approach can be applied to any existing LMs including larger seq2seq LMs (e.g., BART (Lewis et al., 2020), T5 (Raffel et al., 2020)).
+
+Can SCORE deliver more value when in-domain data is limited (e.g., in a low-resource setting)? We want to answer this question similar to experiments other investigations of LMs as few-shot learners (Wu et al., 2020; Brown et al., 2020; Schick & Schutze, 2020). To ¨ this end, we compare ROBERTA and SCORE under a few-shot setting on SQA when only $10 \%$ of training data is available. We choose SQA because its annotation is most different from the synthetic text-to-SQL dataset we use for pretraining. Table 9 demonstrates that SCORE delivers even larger improvements compared to the ROBERTA baseline when only $10 \%$ training data is available $3 . 8 \%$ vs $2 . 6 \%$ ).
+
+<table><tr><td></td><td>QM</td><td>IM</td></tr><tr><td>RoBERTa</td><td>53.3</td><td>21.2</td></tr><tr><td>SCoRE</td><td>57.1</td><td>26.1</td></tr></table>
+
+Table 9: Performance of SCORE on $10 \%$ training data of SQA.
+
+# 5 RELATED WORK
+
+Conversational Semantic Parsing Conversational semantic parsing is one of the most important research topics in conversational AI and has been studied in different settings including task-oriented dialogues, question answering, and text-to-SQL. Task-oriented dialog systems (Henderson et al.,
+
+2014; Wen et al., 2016; Mrksiˇ c et al., 2017; Budzianowski et al., 2018) aim to help users accomplish´ a specific task (e.g. flight booking) and often pre-define slot templates grounded in a domainspecific ontology. In comparison, several other datasets were recently introduced for cross-domain conversational text-to-SQL tasks (SPARC and COSQL (Yu et al., 2019a;b)) and sequential questions answers over tables (Iyyer et al., 2017). While the previous work has achieved significant progress in different datasets separately, to the best of our knowledge, we are the first to study four different CSP tasks together (sequential text-to-SQL, conversational text-to-SQL, dialog state tracking, and weakly-supervised sequential question answering) by addressing the shared key challenge of learning representations in pre-trained language models that capture the alignment between the dialogue flow and the structural context.
+
+Conversational Language Model Pre-training Several recent efforts have demonstrated the value of adapting pre-trained LMs to specific tasks using different pre-training objectives, e.g., summarization (Zhang et al., 2019b), knowledge inference (Sun et al., 2019b; Liu et al., 2019a), etc. Closest to our work is adapting pre-trained LMs for open-domain chit-chat models and for tabular data representation. The former focuses on improving response generation on open-ended dialogues by adding a pre-training step on open-domain conversations data, such as Reddit data (Zhang et al., 2020; Henderson et al., 2019). For example, Wu et al. (2020) introduced ToD-BERT, a pre-trained language model combining 9 high-quality human-human task-oriented dialogue datasets to conduct language model and response selection pre-training. However, they use language modeling training objectives over free-form text and therefore have limited ability to represent structural data. The latter has focused on improving language model pre-training for encoding tabular data (Yin et al., 2020; Herzig et al., 2020), but they focus on the single turn semantic parsing setting. Our approach is different from previous work because we address the challenge of conversational semantic parsing tasks by learning pretrained representation for both the multi-turn dynamics of the dialog and the relation between the unstructured language utterance and the structured ontology. Furthermore, our pre-training approach is much more data-efficient than prior LM pre-training work and saves a lot of time and computing resources (Appendix D for more details). Our pre-training step can be done within only one day using 8 V100 GPUs.
+
+Using Synthesized Data for Semantic Parsing Synthesized data has been frequently used in semantic parsing to alleviate the challenge of labeled data scarcity. For example, Wang et al. (2015) proposed a method for training semantic parsers in new domains by generating logical forms and canonical utterances and then paraphrasing the canonical utterances via crowd-sourcing. Similar approaches were used to train semantic parsers in other domains and settings (Zhong et al., 2017; Su et al., 2017; Cheng et al., 2018; Shah et al., 2018). Another line of work has proposed using synthesized data to adapt single turn semantic parsing models to new domains (Jia & Liang, 2016; Yoo et al., 2018; Campagna et al., 2019) and task-oriented dialogues (Campagna et al., 2020). However, they reported that combining synthetic data and the supervised data does not yield significant improvements, consistent with results by Herzig et al. (2020). By contrast, we introduce a new data synthesize procedure for conversational text-to-SQL dialogues and use it in a different way by pretraining language models to induce better representations for many CSP tasks. Our synthesized data can be easily generated without human involvement and the pre-trained models add value to different tasks simultaneously.
+
+# 6 CONCLUSION
+
+We presented SCORE a new pre-training approach for conversational semantic parsing. The training objectives of SCORE aim to induce natural language representations that capture the multi-turn dynamics, compositional semantic of the target language, and the references to the structural ontology appearing in the dialog. SCORE can be used with many semantic parsing models as a drop-in replacement for general pretrained LMs. We demonstrated SCORE effectiveness by using it as a feature representation encoder with strong baseline models for a wide range of CSP tasks. In particular, our empirical results on four different CSP tasks demonstrated that SCORE can be used to significantly improve the performance of existing strong baseline models by simply replacing an existing pre-trained LM with our SCORE pre-trained model. Furthermore, we are able to achieve state-of-the-art results on three of these tasks. We hope SCORE will encourage further exploration of the benefits and limitations of pre-training approaches for CSP systems.
+
+# REFERENCES
+
+Jimmy Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. ArXiv, abs/1607.06450, 2016.
+
+Chandra Bhagavatula, Thanapon Noraset, and Doug Downey. Tabel: Entity linking in web tables. In International Semantic Web Conference, 2015.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Pawel Budzianowski, Tsung-Hsien Wen, Bo-Hsiang Tseng, Inigo Casanueva, Stefan Ultes, Osman ˜ Ramadan, and Milica Gasic. Multiwoz - a large-scale multi-domain wizard-of-oz dataset for task-oriented dialogue modelling. In EMNLP, 2018.
+
+Giovanni Campagna, Silei Xu, Mehrad Moradshahi, Richard Socher, and Monica S. Lam. Genie: A generator of natural language semantic parsers for virtual assistant commands. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 394–410. Association for Computing Machinery, 2019.
+
+Giovanni Campagna, Agata Foryciarz, Mehrad Moradshahi, and Monica S. Lam. Zero-shot transfer learning with synthesized data for multi-domain dialogue state tracking. In Proceedings of 58th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2020.
+
+Joyce Y Chai, Qiaozi Gao, Lanbo She, Shaohua Yang, Sari Saba-Sadiya, and Guangyue Xu. Language to action: Towards interactive task learning with physical agents. In IJCAI, pp. 2–9, 2018.
+
+Jianpeng Cheng, Siva Reddy, and Mirella Lapata. Building a neural semantic parser from a domain ontology. ArXiv, abs/1812.10037, 2018.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019.
+
+Mihail Eric, Rahul Goel, Shachi Paul, Abhishek Sethi, Sanchit Agarwal, Shuyag Gao, and Dilek Hakkani-Tur. Multiwoz 2.1: Multi-domain dialogue state corrections and state tracking baselines. arXiv preprint arXiv:1907.01669, 2019.
+
+Shuyang Gao, Abhishek Sethi, Sanchit Agarwal, Tagyoung Chung, and Dilek Hakkani-Tur. Dialog state tracking: A neural reading comprehension approach. In SIGDial, 2019.
+
+Suchin Gururangan, Ana Marasovic, Swabha Swayamdipta, Kyle Lo, Iz Beltagy, Doug Downey, ´ and Noah A. Smith. Don’t stop pretraining: Adapt language models to domains and tasks. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, Online, July 2020. Association for Computational Linguistics.
+
+M. Heck, Carel van Niekerk, Nurul Lubis, Christian Geishauser, Hsien-Chin Lin, M. Moresi, and Milica Gavsi’c. Trippy: A triple copy strategy for value independent neural dialog state tracking. In SIGdial, 2020.
+
+Matthew Henderson, Blaise Thomson, and Jason D. Williams. The second dialog state tracking challenge. In SIGDIAL Conference, 2014.
+
+Matthew Henderson, Inigo Casanueva, Nikola Mrkvsi’c, P. Su, Tsung-Hsien, and Ivan Vulic. Convert: ˜ Efficient and accurate conversational representations from transformers. ArXiv, abs/1911.03688, 2019.
+
+Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. ArXiv, abs/1610.02136, 2016.
+
+Jonathan Herzig, P. Nowak, Thomas Muller, Francesco Piccinno, and Julian Martin Eisenschlos. ¨ Tapas: Weakly supervised table parsing via pre-training. In ACL, 2020.
+
+Ehsan Hosseini-Asl, B. McCann, Chien-Sheng Wu, Semih Yavuz, and R. Socher. A simple language model for task-oriented dialogue. ArXiv, abs/2005.00796, 2020.
+
+Wonseok Hwang, Jinyeung Yim, Seunghyun Park, and Minjoon Seo. A comprehensive exploration on wikisql with table-aware word contextualization. ArXiv, abs/1902.01069, 2019.
+
+Mohit Iyyer, Wen-tau Yih, and Ming-Wei Chang. Search-based neural structured learning for sequential question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Vancouver, Canada, July 2017. Association for Computational Linguistics.
+
+Sina Jafarpour, Christopher JC Burges, and Alan Ritter. Filter, rank, and transfer the knowledge: Learning to chat. Advances in Ranking, 10:2329–9290, 2010.
+
+Robin Jia and Percy Liang. Data recombination for neural semantic parsing. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2016.
+
+Sung-Dong Kim, Sohee Yang, Gyuwan Kim, and S. Lee. Efficient dialogue state tracking by selectively overwriting memory. In ACL, 2020.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. BART: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, Online, July 2020. Association for Computational Linguistics.
+
+Q. Liu, B. Chen, Jiaqi Guo, Jian-Guang Lou, Bin Zhou, and Dongmei Zhang. How far are we from effective context modeling ? an exploratory study on semantic parsing in context. ArXiv, abs/2002.00652, 2020.
+
+Weijie Liu, Peng Zhou, Zhe Zhao, Zhiruo Wang, Qi Ju, Haotang Deng, and Ping Wang. K-bert: Enabling language representation with knowledge graph, 2019a.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke S. Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. ArXiv, abs/1907.11692, 2019b.
+
+Nikola Mrksiˇ c, Diarmuid ´ O S ´ eaghdha, Tsung-Hsien Wen, Blaise Thomson, and Steve Young. Neural ´ belief tracker: Data-driven dialogue state tracking. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1777–1788. Association for Computational Linguistics, 2017.
+
+Thomas Muller, Francesco Piccinno, Massimo Nicosia, Peter Shaw, and Yasemin Altun. Answering ¨ conversational questions on structured data without logical forms. In EMNLP/IJCNLP, 2019.
+
+Arvind Neelakantan, Quoc V. Le, M. Abadi, A. McCallum, and Dario Amodei. Learning a natural language interface with neural programmer. ArXiv, abs/1611.08945, 2017.
+
+Panupong Pasupat and Percy Liang. Compositional semantic parsing on semi-structured tables. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing of the Asian Federation of Natural Language Processing, ACL 2015, July 26-31, 2015, Beijing, China, Volume 1: Long Papers, pp. 1470–1480, 2015.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI Blog, 2019.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67, 2020.
+
+Alan Ritter, Colin Cherry, and William B. Dolan. Data-driven response generation in social media. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pp. 583–593, Edinburgh, Scotland, UK., July 2011. Association for Computational Linguistics.
+
+Ohad Rubin and Jonathan Berant. Smbop: Semi-autoregressive bottom-up semantic parsing. arXiv preprint arXiv:2010.12412, 2020.
+
+Timo Schick and Hinrich Schutze. It’s not just size that matters: Small language models are also ¨ few-shot learners. arXiv preprint arXiv:2009.07118, 2020.
+
+Pararth Shah, Dilek Hakkani-Tur, Gokhan T ¨ ur, Abhinav Rastogi, Ankur Bapna, Neha Nayak, and ¨ Larry Heck. Building a conversational agent overnight with dialogue self-play, 2018.
+
+Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), New Orleans, Louisiana, June 2018. Association for Computational Linguistics.
+
+Peter Shaw, Ming-Wei Chang, Panupong Pasupat, and Kristina Toutanova. Compositional generalization and natural language variation: Can a semantic parsing approach handle both? arXiv preprint arXiv:2010.12725, 2020.
+
+Yu Su, Ahmed Hassan Awadallah, Madian Khabsa, P. Pantel, M. Gamon, and Mark J. Encarnacion. ´ Building natural language interfaces to web apis. Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, 2017.
+
+Yibo Sun, Duyu Tang, Nan Duan, Jingjing Xu, X. Feng, and B. Qin. Knowledge-aware conversational semantic parsing over web tables. In NLPCC, 2019a.
+
+Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Xuyi Chen, Han Zhang, Xin Tian, Danxiang Zhu, Hao Tian, and Hua Wu. Ernie: Enhanced representation through knowledge integration, 2019b.
+
+Gokhan Tur and Renato De Mori. Spoken language understanding: Systems for extracting semantic information from speech. John Wiley & Sons, 2011.
+
+Bailin Wang, Ivan Titov, and Mirella Lapata. Learning semantic parsers from denotations with latent structured alignments and abstract programs. In Proceedings of EMNLP, 2019.
+
+Bailin Wang, Richard Shin, Xiaodong Liu, Oleksandr Polozov, and Matthew Richardson. RAT-SQL: Relation-aware schema encoding and linking for text-to-SQL parsers. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 7567–7578, Online, July 2020. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.677.
+
+Yushi Wang, Jonathan Berant, and Percy Liang. Building a semantic parser overnight. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pp. 1332–1342, Beijing, China, July 2015. Association for Computational Linguistics. doi: 10.3115/v1/P15-1129.
+
+Tsung-Hsien Wen, David Vandyke, Nikola Mrksic, Milica Gasic, Lina M Rojas-Barahona, Pei-Hao Su, Stefan Ultes, and Steve Young. A network-based end-to-end trainable task-oriented dialogue system. arXiv preprint arXiv:1604.04562, 2016.
+
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, R’emi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface’s transformers: State-of-the-art natural language processing. ArXiv, abs/1910.03771, 2019.
+
+Chien-Sheng Wu, Andrea Madotto, Ehsan Hosseini-Asl, Caiming Xiong, Richard Socher, and Pascale Fung. Transferable multi-domain state generator for task-oriented dialogue systems. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, July 2019. Association for Computational Linguistics.
+
+Chien-Sheng Wu, Steven C.H. Hoi, Richard Socher, and Caiming Xiong. TOD-BERT: Pre-trained natural language understanding for task-oriented dialogue. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2020.
+
+Pengcheng Yin, Graham Neubig, Wen-tau Yih, and Sebastian Riedel. TaBERT: Pretraining for joint understanding of textual and tabular data. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 8413–8426, Online, July 2020. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.745.
+
+Kang Min Yoo, Youhyun Shin, and Sang goo Lee. Data augmentation for spoken language understanding via joint variational generation, 2018.
+
+Tao Yu, Michihiro Yasunaga, Kai Yang, Rui Zhang, Dongxu Wang, Zifan Li, and Dragomir Radev. Syntaxsqlnet: Syntax tree networks for complex and cross-domain text-to-sql task. In Proceedings of EMNLP. Association for Computational Linguistics, 2018a.
+
+Tao Yu, Rui Zhang, Kai Yang, Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Li, Qingning Yao, Shanelle Roman, Zilin Zhang, and Dragomir Radev. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task. In EMNLP, 2018b.
+
+Tao Yu, Rui Zhang, He Yang Er, Suyi Li, Eric Xue, Bo Pang, Xi Victoria Lin, Yi Chern Tan, Tianze Shi, Zihan Li, Youxuan Jiang, Michihiro Yasunaga, Sungrok Shim, Tao Chen, Alexander Fabbri, Zifan Li, Luyao Chen, Yuwen Zhang, Shreya Dixit, Vincent Zhang, Caiming Xiong, Richard Socher, Walter Lasecki, and Dragomir Radev. Cosql: A conversational text-to-sql challenge towards cross-domain natural language interfaces to databases. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and 9th International Joint Conference on Natural Language Processing. Association for Computational Linguistics, 2019a.
+
+Tao Yu, Rui Zhang, Michihiro Yasunaga, Yi Chern Tan, Xi Victoria Lin, Suyi Li, Irene Li Heyang Er, Bo Pang, Tao Chen, Emily Ji, Shreya Dixit, David Proctor, Sungrok Shim, Vincent Zhang Jonathan Kraft, Caiming Xiong, Richard Socher, and Dragomir Radev. Sparc: Cross-domain semantic parsing in context. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, 2019b. Association for Computational Linguistics.
+
+Jian-Guo Zhang, Kazuma Hashimoto, Chien-Sheng Wu, Yao Wan, Philip S Yu, Richard Socher, and Caiming Xiong. Find or classify? dual strategy for slot-value predictions on multi-domain dialog state tracking. arXiv preprint arXiv:1910.03544, 2019a.
+
+Jingqing Zhang, Yao Zhao, Mohammad Saleh, and Peter J Liu. Pegasus: Pre-training with extracted gap-sentences for abstractive summarization. arXiv preprint arXiv:1912.08777, 2019b.
+
+Rui Zhang, Tao Yu, He Yang Er, Sungrok Shim, Eric Xue, Xi Victoria Lin, Tianze Shi, Caiming Xiong, Richard Socher, and Dragomir Radev. Editing-based sql query generation for cross-domain context-dependent questions. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and 9th International Joint Conference on Natural Language Processing. Association for Computational Linguistics, 2019c.
+
+Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, and Bill Dolan. Dialogpt: Large-scale generative pre-training for conversational response generation. In ACL, system demonstration, 2020.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. CoRR, abs/1709.00103, 2017.
+
+Victor Zhong, M. Lewis, Sida I. Wang, and Luke Zettlemoyer. Grounded adaptation for zero-shot executable semantic parsing. The 2020 Conference on Empirical Methods in Natural Language Processing, 2020.
+
+A DETAILED RESULTS   
+
+<table><tr><td></td><td>QM</td><td>IM</td><td>Q1</td><td>Q2</td><td>Q3</td><td>Q4</td><td>Q5</td></tr><tr><td>RAT-SQL + BERT</td><td>48.4</td><td>19.1</td><td>54.6</td><td>48.4</td><td>47.5</td><td>43.9</td><td>31.0</td></tr><tr><td>+RoBERTa</td><td>50.1</td><td>19.3</td><td>59.7</td><td>50.9</td><td>46.3</td><td>46.5</td><td>32.4</td></tr><tr><td>+ SCoRE</td><td>52.1</td><td>22.0</td><td>60.8</td><td>53.0</td><td>47.5</td><td>49.1</td><td>32.4</td></tr></table>
+
+Table 10: Detailed results of COSQL on the dev set. $\mathrm { Q } _ { i }$ is the accuracy of the $i ^ { \mathrm { { t h } } }$ question in the conversation.   
+
+<table><tr><td></td><td>QM</td><td>IM</td><td>Q1</td><td>Q2</td><td>Q3</td></tr><tr><td>Wang et al. (2019)</td><td>51.0</td><td>22.0</td><td>68.3</td><td>48.0</td><td>38.5</td></tr><tr><td>+RoBERTa</td><td>62.8</td><td>33.2</td><td>77.2</td><td>61.7</td><td>52.1</td></tr><tr><td>+SCoRE</td><td>65.4</td><td>38.5</td><td>78.4</td><td>65.3</td><td>55.1</td></tr><tr><td colspan="6">Few-Shot (10% training data)</td></tr><tr><td>Wang et al. (2019)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>+RoBERTa</td><td>53.3</td><td>21.2</td><td>71.0</td><td>52.5</td><td>36.6</td></tr><tr><td>+SCoRE</td><td>57.1</td><td>26.7</td><td>74.6</td><td>56.7</td><td>40.7</td></tr></table>
+
+Table 11: Detailed results of SQA on the test set. $\mathrm { Q } _ { i }$ is the accuracy of the $i ^ { \mathrm { { t h } } }$ question in the conversation.
+
+# B SYNTHESIZED EXAMPLES & TEMPLATES
+
+Table 12 shows an example of the synthesized question-SQL pairs and their corresponding templates in our grammars.   
+Table 12: An example of synthetic conversational text-to-SQL data.   
+
+<table><tr><td>Turn #</td><td>Question-SQL Template</td><td>Synthesized Question-SQL</td></tr><tr><td>1</td><td>&quot;Find the number of TABLEO with COLUMNO OPO VALUE0&quot; SELECT COUNT(*)ORDER BY COLUMNO OPO VALUEO</td><td>“Find the number of football team with team hometown is not murrieta,california?&quot; SELECT COUNT(*）WHERE TEAM_HOMETOWN !=“MURRIETA, CALIFORNIA&quot;</td></tr><tr><td>2</td><td>“Can you give me their COLUMN1?” TCS: REPLACE(SELECT.COLUMNO), DEL(SELECT.AGG)</td><td>“Can you give me their football team player?” SELECTFOOTBALL_TEAM_PLAYERWHERETEAM_HOMETOWN !=“MURRIETA,CALIFORNIA”</td></tr><tr><td>3</td><td>“How about only show those with AsO cOL- UMN2?” TCS: ADD(ORDERBY_ASO.COLUMN2)</td><td>“How about only show those with the largest age?” SELECTFOOTBALL_TEAM_PLAYER WHERE TEAM_HOMETOWN !=&quot;MURRIETA,CALIFORNIA”ORDER BY AGE DESC LIMIT1</td></tr><tr><td>4</td><td>“AS1?” TCS: REPLACE(ORDERBY_AS1.COLUMN2)</td><td>“The smallest?” SELECTFOOTBALL_TEAM_PLAYER WHERE TEAM_HOMETOWN !=&quot;MURRIETA,CALIFORNIA”ORDER BY AGE AS LIMIT1</td></tr></table>
+
+# C IMPLEMENTATION DETAILS
+
+# C.1 SCORE
+
+For pre-training SCORE on synthesized text-to-SQL data, we use ROBERTA $_ \mathrm { l a r g e }$ and pre-train it with batch size 12, gradient accumulation step 2, and maximum length 248. We use a learning rate 1e-5 and gradually reduce the learning rate without a warm-up period using Adam (Kingma & Ba, 2014) with epsilon 1e-8. $\mathbf { B E R T _ { b a s e } }$ is used in pre-training SCORE on synthesized MWOZ data because it contains longer conversations. We set the maximum length to 512 and batch size 24. All SCORE are pre-trained for 30 epochs, which usually take less than half a day on 8 V100 GPUs.
+
+We experimented with SCORE pre-trained for 5, 10, and 30 epochs and found that most of the best downstream performances occur when base systems incorporate with SCORE pre-trained for less than 10 epochs. Our implementation is based on the Transformers library (Wolf et al., 2019).
+
+# C.2 BASE MODELS
+
+RAT-SQL: For a fair comparison, all RAT-SQL experiments are trained for $4 0 \mathrm { k }$ steps. We adopt the same hyperparameters as Shaw et al. (2018) except for learning rates. We find that learning rates of 1e-4 and 1e-5 for RAT and BERT respectively produce more stable results.
+
+TripPy: We use the same hyperparameters for training TripPy on MWOZ as in (Heck et al., 2020) except we train it for 25 epochs (as opposed to 10 epochs as reported in (Heck et al., 2020)). When we train TripPy for 25 epochs, we get a new result that is higher (around $2 \%$ ) than the one reported in (Heck et al., 2020). Similarly, when we train TripPy with SCORE, we train it for 25 epochs.
+
+SOM-DST: We use the same hyperparameters from Kim et al. (2020) for all SOM-DST experiments on MWOZ.
+
+Wang et al. (2019): We use the same hyperparameters from Wang et al. (2019) for SQA experiments. Note that Herzig et al. (2020) outperform Wang et al. (2019) on SQA because (1) they don’t generate logic forms but select table cells and applying aggregation operators. Wang et al. (2019) generate latent programs, yet the grammar of the latent program can only cover $87 \%$ questions. (2) They reduce the search space by reusing the previous question answer. We choose Wang et al. (2019) as our base model because generating symbolic programs has many practical advantages (even at a cost of around $1 \%$ accuracy drop), such as showing interpretable reasoning steps, enabling formal reasoning, and operationalization without GPU/TPU accelerators.
+
+# D PRE-TRAINING COST
+
+We test the performance of SCORE with respect to the number of pre-training epochs. Figure 3 shows that the best performance of the downstream tasks is usually achieved in early epochs, more specifically 5 for SPARC and COSQL and 15 for MWOZ. Longer pre-training time does not improve or even hurts the performance. One possible reason is that longer pre-training makes SCORE overfit to the synthesized data whose utterances are unnatural.
+
+![](images/f2adaf96d04bd8e302a16e86109313b4514940005cf18a41f431ec1e6bac564a.jpg)  
+Figure 3: The effect of pre-training time.
+
+As for the data, as shown in Table 5, even if SCORE is pre-trained with only a relatively
+
+small amount of synthesized data (without the MLM loss), most of the tasks can achieve much higher performances. With a relatively smaller training corpus and shorter training time compared to other pre-trained language models, SCORE is efficient in time and data.
+
+# E ADDITIONAL RESULTS
+
+Effect of TCS We ran the TCS only experiment on SPARC, and will add TCS only results (including for other tasks) to Table 5 in the final version. SCORE (TCS only) outperforms RoBERTa by $2 . 4 \%$ so far (note: training is still going on) on SPARC $3 9 . 1 \%$ vs. $3 6 . 7 \%$ ). Also, as discussed in Section 4, we also provide a secondary evidence by testing the effectiveness of TCS on SPARC, COSQL, and SQA by adding TCS to CCS (CCS only vs. $\mathrm { C C S + T C S }$ ), SCORE (with TCS) gains improvements of $1 . 2 \%$ on SPARC and $0 . 8 \%$ on COSQL, and $4 . 4 \%$ on SQA.
+
+Incorporating Additional Examples Used in Synthetic Grammar Induction As we mentioned in Section 2.3, we used about 500 examples from SPARC to induce the grammar for data synthesis in pre-training. For a fair comparison, we also report the results of incorporating the additional SPARC examples in COSQL and SQA. More specifically, we directly concatenate the additional SPARC examples to COSQL training set, and train RAT-SQL $^ +$ ROBERTA on it, which slightly improves the performance ( $1 9 . 6 \%$ vs. $1 9 . 3 \%$ ) but not as large as SCORE $2 2 . 0 \%$ vs. $1 9 . 3 \%$ ).’ Also, because SQA is weakly-supervised sequential question answering, which differs from SPARC, we first fine-tune ROBERTA on the additional SPARC examples using CCS, and then apply it to SQA. In this way, the ROBERTA trained with additional SPARC examples achieves a similar performance as the original one $6 2 . 7 \%$ vs $6 2 . 8 \%$ ).
+
+Performance Comparison with ToD-BERT ToD-BERT is pre-trained on human-annotated questions with both MLM and response contrastive objectives. To compare TOD-BERT with SCORE, we ran experiments of RAT-SQL $^ +$ ToD-BERT on SPARC. SCORE $( 6 2 . 2 \% )$ outperforms ToD-BERT $( 5 4 . 6 \% )$ by $7 . 6 \%$ .
+
+Comparison with Finetuning Larger Language Models Based on our experiments and other published results, we didn’t find existing larger LMs (BART (Lewis et al., 2020), T5 (Raffel et al., 2020), GPT-2 (Radford et al., 2019)) outperform custom models $^ +$ BERT on CSP tasks. Our evidence is based on Spider (Yu et al., 2018b), which is the single-turn version of SParC and CoSQL. For T5, Shaw et al. (2020) applied T5 as seq2seq to Spider, and compared with RAT-SQL $^ +$ BERT-Large, T5-Base performs much worse $5 7 . 1 \%$ vs. $6 9 . 6 \%$ ), and T5-3B improves only 0.3, but it is 6 times larger. Moreover, for Bart, we have performed experiments on Spider and we found that BART cannot outperform custom models $^ +$ BERT: RAT-SQL $^ +$ BERT $6 9 . 7 \%$ , RAT-SQL $^ +$ BART encoder $67 . 8 \%$ , BART encoder $^ +$ decoder (406M, as a seq2seq task) $6 2 . 4 \%$ . In Rubin & Berant (2020), BART didn’t outperform BERT either. As for GPT-2, Wu et al. (2020) and Hosseini-Asl et al. (2020) found it does not outperform BERT on MWOZ.
+
+# F TASK-ORIENTED DIALOGUE DATASETS
+
+<table><tr><td rowspan=1 colspan=1>Name</td><td rowspan=1 colspan=1>#Dialogue</td><td rowspan=1 colspan=1>#Utterance</td><td rowspan=1 colspan=1>Avg. Turn</td><td rowspan=1 colspan=1>#Domain</td></tr><tr><td rowspan=1 colspan=1>MetaLWOZ (Lee et al., 2019)</td><td rowspan=1 colspan=1>37,884</td><td rowspan=1 colspan=1>432,036</td><td rowspan=1 colspan=1>11.4</td><td rowspan=1 colspan=1>47</td></tr><tr><td rowspan=1 colspan=1>Schema (Rastogi et al., 2019)</td><td rowspan=1 colspan=1>22,825</td><td rowspan=1 colspan=1>463,284</td><td rowspan=1 colspan=1>20.3</td><td rowspan=1 colspan=1>17</td></tr><tr><td rowspan=1 colspan=1>Taskmaster (Byrne et al.,2019)</td><td rowspan=1 colspan=1>13,215</td><td rowspan=1 colspan=1>303,066</td><td rowspan=1 colspan=1>22.9</td><td rowspan=1 colspan=1>6</td></tr><tr><td rowspan=1 colspan=1>MWOZ (Budzianowski etal.,2018)</td><td rowspan=1 colspan=1>10,420</td><td rowspan=1 colspan=1>71,410</td><td rowspan=1 colspan=1>6.9</td><td rowspan=1 colspan=1>7</td></tr><tr><td rowspan=1 colspan=1>MSR-E2E (Li et al.,2018)</td><td rowspan=1 colspan=1>10.087</td><td rowspan=1 colspan=1>74,686</td><td rowspan=1 colspan=1>7.4</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>SMD (Eric and Manning,2017)</td><td rowspan=1 colspan=1>3,031</td><td rowspan=1 colspan=1>15.928</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Frames (Asri et al.,2017)</td><td rowspan=1 colspan=1>1,369</td><td rowspan=1 colspan=1>19,986</td><td rowspan=1 colspan=1>14.6</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>WOZ (Mrksic et al., 2016)</td><td rowspan=1 colspan=1>1,200</td><td rowspan=1 colspan=1>5,012</td><td rowspan=1 colspan=1>4.2</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>CamRest676 (Wen et al.,2016)</td><td rowspan=1 colspan=1>676</td><td rowspan=1 colspan=1>2,744</td><td rowspan=1 colspan=1>4.1</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Figure 4: Data statistics of human-annotated task-oriented dialogue datasets used in $\mathrm { W u }$ et al. (2020).

parse/train/rJg3zxBYwH/rJg3zxBYwH.md

@@ -0,0 +1,358 @@
+# LEARNING LIKELIHOODS WITH CONDITIONAL NORMALIZING FLOWS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Normalizing Flows (NFs) are able to model complicated distributions $p _ { Y } ( y )$ with strong inter-dimensional correlations and high multimodality by transforming a simple base density $p _ { Z } ( z )$ through an invertible neural network under the change of variables formula. Such behavior is desirable in multivariate structured prediction tasks, where handcrafted per-pixel loss-based methods inadequately capture strong correlations between output dimensions. We present a study of conditional normalizing flows (CNFs), a class of NFs where the base density to output space mapping is conditioned on an input $\mathbf { X }$ , to model conditional densities $p _ { Y \mid X } ( y | x )$ . CNFs are efficient in sampling and inference, they can be trained with a likelihood-based objective, and CNFs, being generative flows, do not suffer from mode collapse or training instabilities. We provide an effective method to train continuous CNFs for binary problems and in particular, we apply these CNFs to super-resolution and vessel segmentation tasks demonstrating competitive performance on standard benchmark datasets in terms of likelihood and conventional metrics.
+
+# 1 INTRODUCTION
+
+Learning conditional distributions $p _ { Y | X } ( \mathbf { y } | \mathbf { x } )$ is one of the oldest problems in machine learning. When the output $\mathbf { y }$ is high-dimensional this is a particularly challenging task, and the practitioner is left with many design choices. Do we factorize the conditional? If not, do we model correlations with, say, a conditional random field (Prince, 2012)? Do we use a unimodal distribution? How fat should the tails be? Do we use an explicit likelihood at all, or use implicit methods (Mohamed & Rezende, 2015) such as a GAN (Goodfellow et al., 2014)? Do we quantize the output? Ideally, the practitioner should not have to make design choices at all, and the distribution should be learned from the data.
+
+In the field of density estimation normalizing flows (NFs) are a relatively new family of models (Rezende & Mohamed, 2015). NFs model complicated high dimensional marginal distributions $p _ { Y } ( \mathbf { y } )$ by transforming a simple base distribution or prior $p _ { Z } ( \mathbf { z } )$ through a learnable, invertible mapping $f _ { \phi }$ and then applying the change of variables formula. NFs are efficient in inference and sampling, are able to learn inter-dimensional correlations and multi-modality, and they are exact likelihood models, amenable to gradient-based optimization.
+
+Flow-based generative models (Dinh et al., 2016) are generally trained on the image space, and are in some cases computationally efficient in both the forward and inverse direction. These are advantageous over other likelihood based methods because $i _ { , }$ ) sampling is efficient opposed to autoregressive models (Van Oord et al., 2016), and $i i$ ) flows admit exact likelihood optimization in contrast with variational autoencoders (Kingma & Welling, 2014).
+
+Conditional random fields directly model correlations between pixels, and have been fused with deep learning (Chen et al., 2016). However, they require the practitioner to choose which pixels have pairwise interactions. Another approach uses adversarial training (Goodfellow et al., 2014). A downside is that the training procedure can be unstable and they are difficult to evaluate quantitatively.
+
+We propose to learn the likelihood of conditional distributions with few modeling choices using Conditional Normalizing Flows (CNFs). CNFs can be harnessed for conditional distributions $p _ { Y | X } ( \mathbf { y } | \mathbf { x } )$
+
+by conditioning the prior and the invertible mapping on the input x. In particular, we apply conditional flows to super-resolution (Wang et al., 2018) and vessel segmentation (Staal et al., 2004). We evaluate their performance gains on multivariate prediction tasks along side architecturally-matched factored baselines by comparing likelihood and application specific evaluation metrics.
+
+# 2 BACKGROUND
+
+In the following, we present the relevant background material on normalizing flows and structured prediction. This section covers the change of variables formula, invertible modules, variational dequantization and conventional likelihood optimization.
+
+# 2.1 NORMALIZING FLOWS
+
+A standard NF in continuous space is based on a simple change of variables formula. Given two spaces of equal dimension $\mathcal { Z }$ and $\mathcal { V }$ ; a once-differentiable, parametric, bijective1 mapping $f _ { \phi } : \mathcal { V } $ $\mathcal { Z }$ , where $\phi$ are the parameters of $f$ ; and a prior distribution $p _ { Z } ( \mathbf { z } )$ , we can model a complicated distribution $p _ { Y } ( \mathbf { y } )$ as
+
+$$
+p _ { Y } ( \mathbf { y } ) = p _ { Z } ( f _ { \phi } ( \mathbf { y } ) ) \left. \frac { \partial f _ { \phi } ( \mathbf { y } ) } { \partial \mathbf { y } } \right. .
+$$
+
+The term $| \partial f _ { \phi } ( \mathbf { y } ) / \partial \mathbf { y } |$ is the Jacobian determinant of $f _ { \phi }$ , evaluated at $\mathbf { y }$ and it accounts for volume changes induced by $f _ { \phi }$ . The transformation $f _ { \phi }$ introduces correlations and multi-modality in $p _ { Y }$ . The main challenge in the field of normalizing flows is designing the transformation $f _ { \phi }$ . It has to be $i ,$ bijective, $i i _ { . }$ ) have an efficient and tractable Jacobian determinant, iii) be from a ‘flexible’ model class. In addition, $i \nu _ { . }$ ) for fast sampling the inverse needs to be efficiently computable. Below we briefly state which invertible modules are used in our architectures, obeying the aforementioned points.
+
+Coupling layers Affine coupling layers (Dinh et al., 2016) are invertible, nonlinear layers. They work by splitting the input $\mathbf { z }$ into two components $\mathbf { z } _ { 0 }$ and $\mathbf { z } _ { 1 }$ and nonlinearly transforming $\mathbf { z } _ { 0 }$ as a function of $\mathbf { z } _ { 1 }$ , before reconcatenating the result. If ${ \bf z } = [ { \bf z } _ { 0 } , { \bf z } _ { 1 } ]$ and $\mathbf { y } = [ \mathbf { y } _ { 0 } , \mathbf { y } _ { 1 } ]$ this is
+
+$$
+\begin{array} { r l r l } & { \mathbf { y } _ { 0 } = s ( \mathbf { z } _ { 1 } ) \cdot \mathbf { z } _ { 0 } + t ( \mathbf { z } _ { 1 } ) \qquad } & & { \mathbf { z } _ { 0 } = ( \mathbf { z } _ { 0 } - t ( \mathbf { y } _ { 1 } ) ) / s ( \mathbf { y } _ { 1 } ) } \\ & { \mathbf { y } _ { 1 } = \mathbf { z } _ { 1 } \qquad } & & { \mathbf { z } _ { 1 } = \mathbf { y } _ { 1 } } \end{array}
+$$
+
+Where the scale $s ( \cdot )$ and translation $t ( \cdot )$ functions can be any function, typically implemented with a CNN. Similar conditioning with normalizing flows has been done in previous works by Mohamed & Rezende (2015) and Kingma et al. (2016b).
+
+Invertible $\textbf { 1 x 1 }$ Convolutions Proposed in Kingma & Dhariwal (2018), invertible $1 \times 1$ convolutions help mix information across channel dimensions. We implement them as regular $1 \times 1$ convolutions and for the inverse, we convolve with the inverse of the kernel.
+
+Squeeze layers Squeeze layers (Dinh et al., 2016) are used to compress the spatial resolution of activations. These also help with increasing spatial receptive field of pixels in the deeper activations.
+
+Split Prior Split priors (Dinh et al., 2016) work by spliting a set of activations $\mathbf { z }$ into two components $\mathbf { z } _ { 0 }$ and $\mathbf { z } _ { 1 }$ . We then condition $\mathbf { z } _ { 1 }$ on $\mathbf { z } _ { 0 }$ using a simple base density e.g. $p ( \mathbf { z } _ { 1 } | \mathbf { z } _ { 0 } ) =$ $\mathbf { \bar { \mathcal { N } } } ( \mathbf { z } _ { 1 } ; \mu ( \mathbf { z } _ { 0 } ) , \sigma ^ { 2 } ( \mathbf { z } _ { 0 } ) )$ , where $\mu ( \cdot )$ and $\sigma ^ { 2 } ( \cdot )$ are neural networks. The component $\mathbf { z } _ { 0 }$ can be modeled by further flow layers. This prior, is useful for modeling hierarchical correlations between dimensions, and also helps reduce computation, since $\mathbf { z } _ { 0 }$ is reduced in size.
+
+Variational dequantization When modeling discrete data, Theis et al. (2016) introduced the concept of dequantization. For this, they modeled the probability mass function over $\mathbf { y }$ as a latent variable model
+
+$$
+P _ { \mathrm { m o d e l } } ( \mathbf { y } ) = \int _ { \mathcal { V } } P ( \mathbf { y } | \mathbf { v } ) p ( \mathbf { v } ) \mathrm { d } \mathbf { v } = \int _ { \mathcal { V } } p ( \mathbf { y } , \mathbf { v } ) \mathrm { d } \mathbf { v }
+$$
+
+where the latent variables $\textbf { v } \in { \mathcal { V } }$ are continuous-valued. This is a convenient model to use, since the marginal $p ( \mathbf { v } )$ , living on a continuous sample space, can be modelled with a continuous NF. The distribution $P ( \mathbf { y } | \mathbf { v } )$ is known as the quantizer and is typically an indicator function $P ( \mathbf { y } | \mathbf { v } ) = \mathbb { I } [ \mathbf { v } \in$ $\mathbf { y } + [ 0 , 1 ) ^ { D } ]$ . Other works (Hoogeboom et al., $2 0 1 9 \mathrm { a }$ ; Tran et al., 2019) directly model $P _ { \mathrm { m o d e l } } ( \mathbf { y } )$ with a discrete-valued flow, but these are known to be difficult to optimize. As an extension of dequantization, Ho et al. (2019) introduced a variational distribution $\bar { \bf q } ( { \bf v } | { \bf y } )$ , called a dequantizer, and write a lower bound on the data log-likelihood using Jensen’s inequality as follows
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \log P _ { \mathrm { m o d e l } } ( \mathbf { y } ) = \mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \log \displaystyle \int p ( \mathbf { y } , \mathbf { v } ) \mathrm { d } \mathbf { v } } \\ & { \qquad = \mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \log \displaystyle \int \frac { q ( \mathbf { v } | \mathbf { y } ) } { q ( \mathbf { v } | \mathbf { y } ) } p ( \mathbf { y } , \mathbf { v } ) \mathrm { d } \mathbf { v } \geq \mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \int q ( \mathbf { v } | \mathbf { y } ) \log \displaystyle \frac { p ( \mathbf { y } , \mathbf { v } ) } { q ( \mathbf { v } | \mathbf { y } ) } \mathrm { d } \mathbf { v } } \end{array}
+$$
+
+Noting that the joint $p ( \mathbf { y } , \mathbf { v } ) = \mathbb { I } [ \mathbf { v } \in \mathbf { y } + [ 0 , 1 ) ^ { D } ] p ( \mathbf { v } )$ , we see that the dequantizer distribution $q ( \mathbf { v } | \mathbf { y } )$ must be defined such that $\mathbf { v } \in \mathbf { y } + [ 0 , 1 ) ^ { D }$ , otherwise $p ( \mathbf { y } , \mathbf { v } ) = 0$ and the lower-bound is undefined. Restricting $q ( \mathbf { v } | \mathbf { y } )$ to satisfy this condition, results in the following variational dequantization bound
+
+$$
+\mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \log P _ { \mathrm { m o d e l } } ( \mathbf { y } ) \geq \mathbb { E } _ { P _ { \mathrm { d a t a } } ( \mathbf { y } ) } \int q ( \mathbf { v } | \mathbf { y } ) \log \frac { p ( \mathbf { v } ) } { q ( \mathbf { v } | \mathbf { y } ) } \mathrm { d } \mathbf { v } .
+$$
+
+# 2.2 STRUCTURED PREDICTION
+
+Structured prediction tasks such as image segmentation or super-resolution, can be probabilistically framed as learning an unknown target distribution $p ^ { * } ( \mathbf { y } \vert \mathbf { x } )$ , with an input $\mathbf { x } \in \mathcal { X }$ and a target $\mathbf { y } \in \mathcal { V }$ . In practice with deep learning models, the unknown distribution is often learned by a factored model:
+
+$$
+p ( \mathbf { y } | \mathbf { x } ) = \prod _ { d = 1 } ^ { D } p ( y _ { d } | \mathbf { x } ) ,
+$$
+
+where $y _ { d }$ represents the dth dimension of y. Several loss-based optimization methods are a special case of this factored model. The mean squared error is equivalent to a product of normal distributions with equal and fixed standard deviation. Other examples are: cross entropy, equivalent to a product of log categorical distributions, and binary cross entropy, equivalent to a product of log Bernoulli distributions.
+
+With factorized independent likelihoods, individual dimensions of y are assumed to be conditionally independent. As a result, sampling leads to results with uncorrelated noise over the output dimensions. In the literature, a fix for this problem is to visualize the mode of the distribution and interpret that as a prediction. However, because the likelihood was optimized assuming a conditionally independent noise distribution, these modes tend to be blurry and lack crisp details.
+
+# 3 METHOD
+
+In this section we present our main innovations. i) learning conditional likelihoods using CNFs and $i i$ ) a variational dequantization framework for binary random variables.
+
+# 3.1 CONDITIONAL NORMALIZING FLOWS
+
+We propose to learn conditional likelihoods using conditional normalizing flows for complicated target distributions in multivariate prediction tasks. Take an input $\mathbf { x } \in \mathcal { X }$ and a regression target $\mathbf { y } \in \mathcal { V }$ . We learn a complicated distribution $p _ { Y | X } ( \mathbf { y } | \mathbf { x } )$ using a conditional prior $p _ { Z | X } ( \mathbf { z } | \mathbf { x } )$ and a mapping $f _ { \phi } : \mathcal { V } \times \mathcal { X } \to \mathcal { Z }$ , which is bijective in $\mathcal { V }$ and $\mathcal { Z }$ . The likelihood of this model is:
+
+$$
+p _ { Y | X } ( \mathbf { y } | \mathbf { x } ) = p _ { Z | X } ( \mathbf { z } | \mathbf { x } ) \left| \frac { \partial \mathbf { z } } { \partial \mathbf { y } } \right| = p _ { Z | X } ( f _ { \phi } ( \mathbf { y } , \mathbf { x } ) | \mathbf { x } ) \left| \frac { \partial f _ { \phi } ( \mathbf { y } , \mathbf { x } ) } { \partial \mathbf { y } } \right| .
+$$
+
+Notice that the difference between Equations 1 and 7 is that all distributions are conditional and the flow has a conditioning argument of $\mathbf { x }$ .
+
+The generative process from x to $\mathbf { y }$ (shown in Figure 1) can be described by first sampling $\mathbf { z } \sim$ $p _ { Z | X } ( \mathbf { z } | \mathbf { x } )$ from a simple base density with its parameters conditioned on $\mathbf { x }$ (for us this is a diagonal Gaussian) and then passing it through a sequence of bijective mappings $f _ { \phi } ^ { - 1 } ( \mathbf { z } ; \mathbf { x } )$ . This allows for modelling multimodal conditional distributions in y, which is typically uncommon.
+
+For the training procedure, the process runs in reverse. We begin with label $\mathbf { y }$ and conditioning input $\mathbf { x }$ . We ‘flow’ the label back through $f _ { \phi }$ to yield $\mathbf { z } = f _ { \phi } ( \mathbf { y } ; \mathbf { x } )$ , and then we evaluate the log-likelihood of the parameters of the prior, given this transformed label $\mathbf { z }$ . The flow and prior parameters can be optimized using stochastic gradient descent and training in minibatches in the usual fashion. Note that this style of training a conditional density model $p _ { Y | X } ( \mathbf { y } | \mathbf { x } )$ differs fundamentally from traditional models, because we compute the log-likelihood in $\mathbf { z }$ -space and not y-space. As a result, we are not biasing our results with an arbitrary choice of output-space likelihood or in the case of this paper, handcrafted image loss. Instead, one could interpret this method as learning the correlational and multimodal structure of the likelihood or simply put loss-learning.
+
+![](images/1d00c1a305b002fe4da20995d0fabb8d03ca5c203d3362bd2c40e5bad8b0f3e7.jpg)  
+Figure 1: Diagram of our model in the train and sampling phases. Solid lines represent deterministic mappings and dashed lines represent sampling. The conditioning variable enters the network in base density $p ( \mathbf { z } | \mathbf { x } )$ and the bijective mappings $f ( \mathbf { y } , \mathbf { x } )$ .
+
+Conditional modules In our work, the conditioning is introduced in the prior, the split priors, and the affine coupling modules. For the prior, we set the mean and variance as functions of $\mathbf { x }$ . For the split prior, we add $\mathbf { x }$ as a conditoning argument to the conditional $p ( \mathbf { z } _ { 1 } | \mathbf { z } _ { 0 } , \mathbf { x } )$ . And for the affine coupling layers, we pass $\mathbf { x }$ to the scale and translation networks so that
+
+$$
+\begin{array} { r l } & { \mathrm { C o n d i t i o n a l ~ P r i o r } \qquad p ( \mathbf { z } | \mathbf { x } ) = \mathcal { N } ( \mathbf { z } ; \mu ( \mathbf { x } ) , \sigma ^ { 2 } ( \mathbf { x } ) ) } \\ & { \mathrm { C o n d i t i o n a l ~ S p l i t ~ P r i o r } \quad p ( \mathbf { z } _ { 1 } | \mathbf { z } _ { 0 } , \mathbf { x } ) = \mathcal { N } ( \mathbf { z } _ { 1 } ; \mu ( \mathbf { z } _ { 0 } , \mathbf { x } ) , \sigma ^ { 2 } ( \mathbf { z } _ { 0 } , \mathbf { x } ) ) } \\ & { \mathrm { C o n d i t i o n a l ~ C o u p l i n g } \quad \mathbf { y } _ { 0 } = s ( \mathbf { z } _ { 1 } , \mathbf { x } ) \cdot \mathbf { z } _ { 0 } + t ( \mathbf { z } _ { 1 } , \mathbf { x } ) ; \qquad \mathbf { y } _ { 1 } = \mathbf { z } _ { 1 } } \end{array}
+$$
+
+In practice these functions are implemented using deep neural networks. First the conditioning term $\mathbf { x }$ is transformed into a rich representation $\mathbf { h } = g ( \mathbf { x } )$ using a large network $g$ . Subsequently, each function in the flow is applied to a concatenation $[ \cdot , \cdot ]$ of $\mathbf { h }$ and the relevant part of $\mathbf { z }$ . For example, the translation of a conditional coupling is computed as $t ( \mathbf { z } _ { 1 } , \mathbf { x } ) = \mathbf { N N } ( [ \mathbf { z } _ { 1 } , \mathbf { h } ] )$ .
+
+# 3.2 VARIATIONAL DEQUANTIZATION FOR BINARY RANDOM VARIABLES
+
+We generalize the variational dequantization scheme for the binary setting. Let $\mathbf { y } \in \{ 0 , 1 \} ^ { D }$ be a multivariate binary random variable and $\mathbf { v } \in \mathbb { R } ^ { D }$ its dequantized representation. In Ho et al. (2019) the bound is not guaranteed to be tight, since there is a domain mismatch in the support of $p ( \mathbf { v } )$ and the variational dequantizer $q ( \mathbf { v } | \mathbf { y } )$ . Technically, if $p ( \mathbf { v } )$ is modeled as a bijective mapping from a Gaussian distribution where the mapping only has finite volume changes, then the support of $p ( \mathbf { v } )$ is unbounded. On the otherhand, the support of the dequantizer is bounded and so we have to redefine either the dequantizer to map to all of $\mathbb { R } ^ { D }$ or restrict the support of the flow to a bounded volume inside $\mathbb { R } ^ { D }$ . We resolve this by dequantizing with half-infinite noise, where
+
+$$
+\mathbf { v } | \mathbf { y } , \mathbf { z } = 0 . 5 + \mathrm { s i g n } ( \mathbf { y } - 0 . 5 ) \cdot \mathrm { s o f t p l u s } ( \mathrm { N N } ( \mathbf { z } ) ) .
+$$
+
+The softplus guarantees that samples from the neural network NN are only positive. If $\mathbf { y }$ is 1, the term $\mathrm { s i g n } ( \mathbf { y } - 0 . 5 )$ outputs positive-valued noise and if $\mathbf { y }$ is 0 the noise is negative-valued.
+
+# 4 RELATED WORK
+
+Normalizing flows were originally introduced to machine learning to learn a flexible variational posterior, a conditional distribution, in VAEs (Rezende & Mohamed, 2015; Kingma et al., 2016a; van den Berg et al., 2018). Flow-based generative models (Dinh et al., 2016; Papamakarios et al., 2017; Huang et al., 2018; Kingma & Dhariwal, 2018; Hoogeboom et al., 2019b; Grathwohl et al., 2019; Cao et al., 2019; Chen et al., 2019) are typically trained directly in the data space. Several of these are designed to be fast to invert, which makes them suitable for drawing samples after training.
+
+Different versions and applications of conditional normalizing flows include Agrawal & Dukkipati (2016) who utilize flows in the decoder of Variational AutoEncoders Kingma & Welling (2014), which are conditioned on the latent variable. Trippe & Turner (2018) who utilize conditional flows for prediction problems in a Bayesian framework for density estimation. Atanov et al. (2019) introduce a semi-conditional flow that provides an efficient way to learn from unlabeled data for semisupervised classification problems. Very recently, Ardizzone et al. (2019) have proposed conditional flow-based generative models for image colorization, which differs from our work in training objective, architecture and applicability to binary segmentation. Autoregressive models (Van Oord et al., 2016) have also been studied for conditional image generation van den Oord et al. (2016) but are generally slow to sample from.
+
+Adversarial methods (Goodfellow et al., 2014) have widely been applied to (conditional) image density modeling tasks (Vu et al., 2019; Sajjadi et al., 2017b; Yuan et al., 2018; Mechrez et al., 2018), because they tend to generate high-fidelity images. Disadvantages of adversarial methods are that they can be complicated to train, and it is difficult to obtain likelihoods. For this reason, it can be hard to assess whether they are overfitting or generalizing.
+
+# 5 EXPERIMENTS
+
+Here we explain our experiments into super-resolution and vessel segmentation. All models were implemented using the PyTorch framework.
+
+# 5.1 SINGLE IMAGE SUPER RESOLUTION
+
+Single Image Super Resolution (SISR) methods aims to find a high resolution image $x _ { h r }$ given a single (downsampled) low resolution image $x _ { l r }$ . Framing this problem as learning a likelihood, we utilize a CNF to learn the distribution $p ( x _ { h r } | x _ { l r } )$ . To compare our method we also train a factorized baseline likelihood model with comparable architectures and parameter budget. The factorized baseline uses a product of discretized logistic distributions (Kingma et al., 2016a; Salimans et al., 2017). All methods are compared on negative $\log _ { 2 }$ -likelihood if available, which has the information theoretic interpretation bits per dimensions. In addition, we evaluate using SSIM (Wang et al., 2004) and PSNR metrics.
+
+Implementation Details The flow is based on the (Dinh et al., 2016; Kingma & Dhariwal, 2018) multi-scale architectures. Each step of flow consists of $K$ subflows and $L$ levels. One subflow consists of an activation normalization, $1 \times 1$ convolution, and our conditional coupling layer. After completing a level, half of the representation is factored-out and modeled using our conditional split prior. After all levels have been completed, our conditional prior is used to model the final part of the latent variable.
+
+The conditioning variable $x _ { l r }$ is transformed into the feature representation h using Residual-inResidual Dense Block (RRDB) architecture (Wang et al., 2018), consisting of 16 residual-in-residual blocks. To match the parameter budget, the channel growth is 55 for the baseline and the growth is 32 for the CNF.
+
+Data The models are trained on natural image datasets, Imagenet32 and Imagenet64 (Chrabaszcz et al., 2017). Since the dataset has no test set, we use its validation images as a test set. For validation we take 10000 images from the train images. The performance is always reported on the test set unless specified otherwise. We evaluate our models on widely used benchmark datasets Set5 (Bevilacqua et al., 2012), Set14 (Zeyde et al., 2012) and BSD100 (Huang et al., 2015). At test time, we pad the test images with zeros at right and bottom so that they are square and compatible with squeeze layers. When evaluating on SSIM and PSNR, we can extract the patch with the exact image shape. For all datasets the LR images are obtained using MATLABs bicubic kernel function with reducing aliasing artifacts following Wang et al. (2018). For these experiments, the pixel values are dequantized by adding uniform noise (Theis et al., 2016).
+
+Training Settings We train on ImageNet32 and ImageNet64 for 200, 000 iterations with mini batches of size 64, and a learning rate of 0.0001 using the Adam optimizer (Kingma & Ba, 2015).
+
+![](images/968b128bcb0c0904815de5b4636633af6dac527cda75f1e445b409699c0fcf5b.jpg)  
+Figure 2: Super resolution results on the Imagenet64 test data. Samples are taken from the CNF $x _ { h r } \sim p ( x _ { h r } | x _ { l r } )$ and the mode is visualized for the factorized baseline model. Best viewed electronically.
+
+The high-resolution image $x _ { h r }$ either the original $3 2 \times 3 2$ or $6 4 \times 6 4$ original input images. The flow architecture is build with $L = 2$ levels and $K = 8$ .
+
+# 5.1.1 EVALUATION
+
+In this section the performance of CNFs for SISR is compared against a baseline likelihood model on ImageNet32 and ImageNet64. Their performance measured in $\log _ { 2 }$ -likelihood (bits per dimension) is shown in Table 1, which show that the CNF outperforms the factorized baseline in likelihood. Recall that the baseline model is factorized and conditionally independent. These results indicate that it is advantageous to capture the correlations and multi-modality present in the data.
+
+Table 1: Comparison of likelihood learning with CNFs and factorized discrete baseline on ImageNet32 and ImageNet64 measured in bits per dimensions.   
+
+<table><tr><td>Dataset</td><td>CNF</td><td>factorized LL</td></tr><tr><td>ImageNet32</td><td>3.01</td><td>4.00</td></tr><tr><td>ImageNet64</td><td>2.90</td><td>3.61</td></tr></table>
+
+Super resolution samples $x _ { h r } \sim p ( x _ { h r } | x _ { l r } )$ from the Imagenet64 test data are shown in Figure 2. The distribution mode of the factorized baseline is displayed in Figure 2 panel c). We show that the baseline is able to learn a relationship between conditioning variable $\mathbf { x }$ and $\mathbf { y }$ , but lacks crisp details. The super-resolution images from the CNF are shown in panel b). Notice there are more high-frequency components modelled, for instance in grass and in hairs. Following Kingma & Dhariwal (2018), we sample from the base distributions with a temperature $\tau$ of 0.8 to achieve the best perceptual quality for the distribution learned by the CNF.
+
+As there are no standard metric for measuring perceptual quality, we measure performance results on PSNR and SSIM between our predicted image and the ground truth image in Table 2. We compare CNFs to other state-of-the-art per-pixel loss based methods and the factorized baseline for a $2 \mathbf { x }$ upsampling task on standard super-resolution benchmarks. If available, we report negative $\log _ { 2 ^ { - } }$ likelihood (bpd) (computed as an average over 1000 randomly cropped $1 2 8 \mathrm { ~ x ~ } 1 2 8$ patches). Note that without any hyperparameter tuning or compositional loss weighting, as is typical in SISR, the CNF performs competitively with state-of-the-art super-resolution methods by simply optimizing the likelihood. The SSIM scores for the baseline perform on par or better than the adversarial methods and the CNF on all benchmarks. On PSNR scores however, the CNF beats the factorized discrete baseline. Samples shown in Figure 3 show that the CNF predictions have more fine grained texture details. Comparing this finding with the baseline that outperforms every method on SSIM, show that metrics can be misleading.
+
+Notice how samples from a independent factorized likelihood model have a lot of color noise, whereas samples from the CNF do not have such problems. Increasing temperature increases highlevel detail, where we find that $\tau = 0 . 5$ strikes a balance between noise smoothing and detail. This can be attributed to the property of flows to model pixel correlations among output dimensions for high-dimensional data such as images.
+
+![](images/5602ea26bc9f0019bce5ce039c4e3071ca127744d2404a6971011ac9cc775f23.jpg)  
+Figure 3: Conditional samples from the CNF (ours) for sampling temperatures $\{ 0 . , 0 . 5 , 1 . 0 \}$ and the factorized discrete baseline for $2 \mathbf { x }$ upscaling. Conditioning image is a baboon from Set14 test set. Both models were trained on ImageNet64. Best viewed electronically.
+
+Table 2: CNF compared to factorized discrete baseline and adversarial, pixel-wise methods (Dong et al., 2015; Sajjadi et al., 2017a; Prez-Pellitero et al., 2016) based on negative $\log _ { 2 }$ -likelihood (bits per dimension or bpd), PSNR, SSIM and for $2 \mathbf { x }$ upscaling. Our methods were trained on ImageNet64.   
+
+<table><tr><td></td><td></td><td>Set5</td><td colspan="5">Set14</td><td>BSD100</td><td></td></tr><tr><td>Model Type</td><td>bpd</td><td>PSNR</td><td>SSIM 1</td><td>bpd</td><td>PSNR</td><td>SSIM</td><td>bpd</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td>-</td><td>33.7</td><td>0.930</td><td>-</td><td>30.2</td><td>0.869</td><td>1</td><td>29.6</td><td>0.843</td></tr><tr><td>SRCNN</td><td>1</td><td>36.7</td><td>0.954</td><td>1</td><td>32.4</td><td>0.906</td><td>1</td><td>31.4</td><td>0.888</td></tr><tr><td>PSyCO</td><td>1</td><td>36.9</td><td>0.956</td><td>-</td><td>32.6</td><td>0.898</td><td>1</td><td>31.4</td><td>0.890</td></tr><tr><td>ENet</td><td>1</td><td>37.3</td><td>0.958</td><td>1</td><td>33.3</td><td>0.915</td><td>1</td><td>32.0</td><td>0.898</td></tr><tr><td>LL Baseline</td><td>2.34</td><td>32.5</td><td>0.958</td><td>3.23</td><td>31.0</td><td>0.917</td><td>3.20</td><td>30.6</td><td>0.900</td></tr><tr><td>CNF (ours)</td><td>2.11</td><td>36.2</td><td>0.957</td><td>2.51</td><td>32.5</td><td>0.911</td><td>2.33</td><td>31.4</td><td>0.893</td></tr></table>
+
+# 5.2 VESSEL SEGMENTATION
+
+Vessel segmentation is an important, long-standing, medical imaging problem, where we seek to segment blood vessels from pictures of the retina (the back of the eye). This is a difficult task, because the vessels are thin and of varying thickness. A likelihood function used in segmentation is
+
+![](images/64404a415db694e85d9227c5b4fd54d66608ebbee408c1463360b6822919ce1f.jpg)  
+Figure 4: Example of retinal segmentations using DRIU, our likelihood baseline trained with the same loss, and our CNF. For the CNF, the mean of 100 samples is visualized. Notice that our segmentations more accurately capture the vessel width, which is overdilated in the DRIU and factored models.
+
+Table 3: Numerical results on the DRIVE dataset. We see that the CNF is in the range of the SOTA model DRIU. SE: Structured Forests (Dollar & Zitnick, 2013), LD: Line Detector (Ricci & Perfetti, ´ 2007), Wavelets (Soares et al., 2006), Human (Staal et al., 2004), HED: Holistic Edge Detector (Xie & Tu, 2015), KB: Kernel Boost Becker et al. (2013), $N ^ { 4 }$ : $N ^ { 4 }$ Fields (Ganin & Lempitsky, 2014), DRIU: Deep Retinal Image Understanding (Maninis et al., 2016). Our answers are shown in mean ± 1std form, where statistics are taken over 5 runs.   
+
+<table><tr><td></td><td>SE</td><td>LD</td><td>Wavelets</td><td>Human</td><td>HED</td><td>KB</td><td>N4</td><td>DRIU</td><td>Factored (ours)</td><td>CNF Uniform (Ours)</td><td>CNF (ours)</td></tr><tr><td>bpd</td><td></td><td></td><td></td><td>■</td><td>=</td><td>=</td><td></td><td></td><td>0.0647 ± 0.0015</td><td>0.3366 ± 0.0290</td><td>0.0254± 0.0008</td></tr><tr><td>F-Score</td><td>0.658</td><td>0.692</td><td>0.762</td><td>0.791</td><td>0.794</td><td>0.800</td><td>0.805</td><td>0.821</td><td>0.815 ± 0.001</td><td>0.762 ± 0.002</td><td>0.819 ± 0.001</td></tr></table>
+
+a weighted Bernoulli distribution
+
+$$
+\mathcal { L } = \prod _ { j } \frac { p _ { j } ^ { \beta \cdot y _ { j } } ( 1 - p _ { j } ) ^ { ( 1 - \beta ) \cdot ( 1 - y _ { j } ) } } { p _ { j } ^ { \beta } + ( 1 - p _ { j } ) ^ { 1 - \beta } }
+$$
+
+where $p _ { j } = p ( y _ { j } = 1 | \mathbf { x } )$ is the prediction probability that pixel $y _ { j }$ is positive (vessel class) and $\beta$ is a class balancing constant set to $\sim 1 0 \%$ for us. This loss function is preferred, because it accounts for the apparent class imbalance in the ratio of vessels to background. In practice, the numerator of this likelihood is used as a loss function and the normalizer is ignored. The resulting loss is called a weighted cross-entropy. In our experiments we train using the weighted cross-entropy (as in the literature), but we report likelihood values including the normalizer, for a meaningful comparison.
+
+Dataset and comparisons We test on the DRIVE database Staal et al. (2004) consisting of $5 8 4 \times$ 565, 8-bit RGB images, split into 20 train, and 20 test images. To compare against other methods, we plot precision-recall curves, report the maximum F-score along each curve (shown as a dot in the graph), report the bits per dimension, and plot distributions in PR-space. The main CNN-based contenders are Deep Retinal Image Understanding (DRIU) (Maninis et al., 2016) and HolisticallyNested Edge Detection (HED) (Xie & Tu, 2015), both of which are instances of Deeply-Supervised Nets (Lee et al., 2015). The main difference between DRIU and HED is that DRIU is pretrained on ImageNet Krizhevsky et al. (2012); whereas, HED is not. Other competing methods are reported with results cited from (Maninis et al., 2016). For fairness, we also train a model which we call the likelihood baseline, which uses the exact same architecture as the flow but run a feedforward model and trained with the weighted Bernoulli loss.
+
+Implementation The flow is identical to the flow used in the previous section, with some key differences. i) instead of activation normalization, we use instance normalization (Ulyanov et al., 2016), ii) the conditional affine coupling layers do not contain a scaling component $s ( \cdot )$ but just the translation $t ( \cdot )$ , hence it is volume preserving, and iii) we train using variational dequantization. Since the data is binary-valued, we dequantize according to the Flow $^ { + + }$ scheme of Ho et al., modified to binary variables (see Section 3.2), using a CNF at just a single scale for the dequantizer. The CNF is conditioned on resolution-matched features extracted from a VGG-like network Simonyan & Zisserman (2015). This model is composed of blocks of the form block $=$ [InstanceNorm, ReLU, conv], and $2 \mathbf { x } 2$ max-pooling layer, shown in Table 4. All filter sizes are $3 { \tt X } 3$ . The outputs are at layers 4 and 7. These are used to condition the resolution 512 and 256 levels of the CNF, respectively.
+
+Table 4: Feature extractor architecture for retinal vessel segmentation. RES. abbreviates resolution. Outputs are at layer 4 and 7.   
+
+<table><tr><td rowspan=1 colspan=1>LAYER</td><td rowspan=1 colspan=1>TYPE</td><td rowspan=1 colspan=1>RES.</td></tr><tr><td rowspan=1 colspan=1>01</td><td rowspan=1 colspan=1>inputblock</td><td rowspan=1 colspan=1>10241024</td></tr><tr><td rowspan=1 colspan=1>234</td><td rowspan=1 colspan=1>max-poolblockblock</td><td rowspan=1 colspan=1>512512512</td></tr><tr><td rowspan=3 colspan=1>567</td><td rowspan=3 colspan=1>max-poolblockblock</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>256</td></tr></table>
+
+Training/test settings We train using the Adam optimizer at learning rate 0.001, and a minibatch size of 2 for 2000 epochs. All images are padded to $1 0 2 4 \mathrm { x } 1 0 2 4$ pixels, so that they are compatible with squeeze layers. We use $3 6 0 ^ { \circ }$ rotation augmentation, isotropic scalings in the range [0.8, 1.2], and shears drawn from a normal distribution with standard deviation $1 0 ^ { \circ }$ . At test time we draw samples from our model and compare those against the groundtruth labels. This contrasts with other methods, that measure labels against thresholded versions of a factorized predictive distribution. To create the PR curve in Figure 5 we take the average of 100 samples and threshold the resulting map (example shown in Figure 4). While crude, this mean image is useful in defining a PR-curve, since there is not great topology change between samples.
+
+Evaluation The results of our experiments are shown in Table 3 and Figure 5, with a visualization in Figure 4. We see in the table that the CNF trained with our binary dequantization achieves the best bits per dimension, with comparable F-score to the state of the art model (DRIU), but our model does not require pretraining on ImageNet. Interestingly, we found training a flow with uniform dequantization slightly unstable and the results were far from satisfactory. In the PR-curve Figure 5, we show a comparable curve for our binary dequantized CNF to the DRIU model. These results, however, say nothing about the calibration of the probability outputs, but just that the various probability predictions are well ranked. To gain an insight into the calibration of the probabilities, we measure the distribution of precision and recall values for point samples drawn from all models, including a second human grader, present in the original DRIVE dataset. We synthesized samples from factored distributions (all except ours and ‘human’), by sampling images from a factored Bernoulli with mean as the soft image. We see the results in the right hand plot of Figure 5, which shows that while the other CNN-based methods such as DRIU or HED have good precision, they suffer in term of recall. On the other hand, the CNF drops in precision a little bit, but makes up for this in terms of high recall, with a PR distribution overlapping the human grader. This indicates that the CNF has learned a well-calibrated distribution, compared to the baseline methods. Further evidence of this is seen in the visualization in Figure 4, which shows details from the predicted means (soft images). This shows that the DRIU and likelihood baseline overdilate segmentations and the CNF does not. This can be explained from the fact that in the weighted Bernoulli it is cheaper to overdilate than to underdilate. Since the CNF contains no handcrafted loss function, we circumvent this pathology.
+
+![](images/258f0bc2d5bbcbd0d20d8a912778473082ec933769f1dc7b2d5eb4d68b02c020.jpg)  
+Figure 5: Here we show two visualizations of the same data. LEFT: We show the PR-curves generated from a sweeping threshold on soft images output by each listed method. Maximal F-scores for each curve are shown as circles with the green lines indicating constant F-score. We see that our method beats all traditional methods and is on par with DRIU, which unlike us was pretrained on Imagenet. RIGHT: We show a scatter plot in PR-space of samples drawn from each model. To draw samples from the all factored models, we sample images from a factored Bernoulli with a mean as the soft image. We see that the DRIU and HED models, while having good precision, have poor recall in this regime. This indicates that while the output of their networks produce a good ranking of probabilities, the values of the probabilities are poorly calibrated. For us, we drop in precision slightly, but gain greatly in terms of recall, indicating that our samples are drawn from a better calibrated distribution, overlapping significantly with the Human distribution.
+
+# 6 CONCLUSION
+
+In this paper we propose to learn likelihoods of conditional distributions using conditional normalizing flows. In this setting, supervised prediction tasks can be framed probabilistically. In addition, we propose a generalization of variational dequantization for binary random variables, which is useful for binary segmentation problems. Experimentally we show competitive performance with competing methods in the domain of super-resolution and binary image segmentation.
+
+# REFERENCES
+
+Siddharth Agrawal and Ambedkar Dukkipati. Deep variational inference without pixel-wise reconstruction. CoRR, abs/1611.05209, 2016.
+
+Lynton Ardizzone, Carsten Luth, Jakob Kruse, Carsten Rother, and Ullrich K ¨ othe. Guided im- ¨ age generation with conditional invertible neural networks. CoRR, abs/1907.02392, 2019. URL http://arxiv.org/abs/1907.02392.
+
+Andrei Atanov, Alexandra Volokhova, Arsenii Ashukha, Ivan Sosnovik, and Dmitry Vetrov. Semiconditional normalizing flows for semi-supervised learning. 05 2019.
+
+Carlos J. Becker, Roberto Rigamonti, Vincent Lepetit, and Pascal Fua. Supervised feature learning for curvilinear structure segmentation. In Medical Image Computing and Computer-Assisted Intervention - MICCAI 2013 - 16th International Conference, Nagoya, Japan, September 22-26, 2013, Proceedings, Part I, pp. 526–533, 2013. doi: 10.1007/978-3-642-40811-3\ 66. URL https://doi.org/10.1007/978-3-642-40811-3_66.
+
+Marco Bevilacqua, Aline Roumy, Christine Guillemot, and Marie-Line Alberi-Morel. Lowcomplexity single-image super-resolution based on nonnegative neighbor embedding. In BMVC, 2012.
+
+Nicola De Cao, Wilker Aziz, and Ivan Titov. Block neural autoregressive flow. In Proceedings of the Thirty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI 2019, Tel Aviv, Israel, July 22-25, 2019, pp. 511, 2019.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016. URL http://arxiv.org/abs/1606. 00915.
+
+Ricky T. Q. Chen, Jens Behrmann, David Duvenaud, and Jorn-Henrik Jacobsen. Residual flows for ¨ invertible generative modeling. CoRR, abs/1906.02735, 2019.
+
+Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the CIFAR datasets. CoRR, abs/1707.08819, 2017. URL http://arxiv.org/ abs/1707.08819.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real NVP. CoRR, abs/1605.08803, 2016. URL http://arxiv.org/abs/1605.08803.
+
+Piotr Dollar and C. Lawrence Zitnick. Structured forests for fast edge detection. In ´ IEEE International Conference on Computer Vision, ICCV 2013, Sydney, Australia, December 1-8, 2013, pp. 1841–1848, 2013. doi: 10.1109/ICCV.2013.231. URL https://doi.org/10.1109/ ICCV.2013.231.
+
+Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Image super-resolution using deep convolutional networks. CoRR, abs/1501.00092, 2015. URL http://arxiv.org/abs/ 1501.00092.
+
+Yaroslav Ganin and Victor S. Lempitsky. $\mathrm { N } ^ { 4 }$ -fields: Neural network nearest neighbor fields for image transforms. CoRR, abs/1406.6558, 2014. URL http://arxiv.org/abs/1406. 6558.
+
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Proceedings of the 27th International Conference on Neural Information Processing Systems - Volume 2, NIPS’14, pp. 2672–2680, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/ citation.cfm?id=2969033.2969125.
+
+Will Grathwohl, Ricky T. Q. Chen, Jesse Bettencourt, Ilya Sutskever, and David Duvenaud. FFJORD: free-form continuous dynamics for scalable reversible generative models. In 7th International Conference on Learning Representations, ICLR 2019, 2019.
+
+Jonathan Ho, Xi Chen, Aravind Srinivas, Yan Duan, and Pieter Abbeel. Flow $^ { + + }$ : Improving flowbased generative models with variational dequantization and architecture design. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019.
+
+Jonathan Ho, Xi Chen, Aravind Srinivas, Yan Duan, and Pieter Abbeel. Flow $^ { + + }$ : Improving flowbased generative models with variational dequantization and architecture design. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 2722–2730, 2019. URL http://proceedings.mlr.press/ v97/ho19a.html.
+
+Emiel Hoogeboom, Jorn W. T. Peters, Rianne van den Berg, and Max Welling. Integer discrete flows and lossless compression. CoRR, abs/1905.07376, 2019a. URL http://arxiv.org/abs/ 1905.07376.
+
+Emiel Hoogeboom, Rianne van den Berg, and Max Welling. Emerging convolutions for generative normalizing flows. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 2019b.
+
+Chin-Wei Huang, David Krueger, Alexandre Lacoste, and Aaron C. Courville. Neural autoregressive flows. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , pp. 2083–2092, 2018.
+
+J. Huang, A. Singh, and N. Ahuja. Single image super-resolution from transformed self-exemplars. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5197–5206, June 2015. doi: 10.1109/CVPR.2015.7299156.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. 2015.
+
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. In Proceedings of the 2nd International Conference on Learning Representations, 2014.
+
+Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016a. URL http://arxiv.org/abs/1606. 04934.
+
+Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016b. URL http://arxiv.org/abs/1606. 04934.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 10236– 10245. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8224-glow-generative-flow-with-invertible-1x1-convolutions.pdf.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems 2012. Proceedings of a meeting held December 3-6, 2012, Lake Tahoe, Nevada, United States., pp. 1106–1114, 2012. URL http://papers.nips.cc/paper/ 4824-imagenet-classification-with-deep-convolutional-neural-networks.
+
+Chen-Yu Lee, Saining Xie, Patrick W. Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. In Proceedings of the Eighteenth International Conference on Artificial Intelligence and Statistics, AISTATS 2015, San Diego, California, USA, May 9-12, 2015, 2015. URL http://proceedings.mlr.press/v38/lee15a.html.
+
+Kevis-Kokitsi Maninis, Jordi Pont-Tuset, Pablo Andres Arbel´ aez, and Luc Van Gool. Deep reti-´ nal image understanding. In Medical Image Computing and Computer-Assisted Intervention - MICCAI 2016 - 19th International Conference, Athens, Greece, October 17-21, 2016, Proceedings, Part II, pp. 140–148, 2016. doi: 10.1007/978-3-319-46723-8\ 17. URL https: //doi.org/10.1007/978-3-319-46723-8_17.
+
+Roey Mechrez, Itamar Talmi, Firas Shama, and Lihi Zelnik-Manor. Learning to maintain natural image statistics. CoRR, abs/1803.04626, 2018. URL http://arxiv.org/abs/1803.04626.
+
+Shakir Mohamed and Danilo J. Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Proceedings of the 28th International Conference on Neural Information Processing Systems - Volume 2, NIPS’15, pp. 2125–2133, Cambridge, MA, USA, 2015. MIT Press. URL http://dl.acm.org/citation.cfm?id ${ . } = { }$ 2969442.2969477.
+
+George Papamakarios, Theo Pavlakou, and Iain Murray. Masked autoregressive flow for density estimation. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 2338–2347. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6828-masked-autoregressive-flow-for-density-estimation.pdf.
+
+Simon JD Prince. Computer vision: models, learning, and inference. Cambridge University Press, 2012.
+
+Eduardo Prez-Pellitero, Jordi Salvador, Javier Ruiz-Hidalgo, and Bodo Rosenhahn. Manifold span reduction for super resolution. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR)., June 2016.
+
+Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 1530–1538, 2015. URL http://proceedings.mlr.press/ v37/rezende15.html.
+
+Elisa Ricci and Renzo Perfetti. Retinal blood vessel segmentation using line operators and support vector classification. IEEE Trans. Med. Imaging, 26(10):1357–1365, 2007. doi: 10.1109/TMI. 2007.898551. URL https://doi.org/10.1109/TMI.2007.898551.
+
+M. S. M. Sajjadi, B. Scholkopf, and M. Hirsch. EnhanceNet: Single image super- ¨ resolution through automated texture synthesis. In Proceedings IEEE International Conference on Computer Vision (ICCV), pp. 4501–4510, Piscataway, NJ, USA, October 2017a. IEEE. URL http://openaccess.thecvf.com/content_ICCV_2017/papers/ Sajjadi_EnhanceNet_Single_Image_ICCV_2017_paper.pdf.
+
+M. S. M. Sajjadi, B. Scholkopf, and M. Hirsch.¨ EnhanceNet: Single image superresolution through automated texture synthesis. In Proceedings IEEE International Conference on Computer Vision (ICCV), pp. 4501–4510, Piscataway, NJ, USA, October 2017b. IEEE. URL http://openaccess.thecvf.com/content_ICCV_2017/papers/ Sajjadi_EnhanceNet_Single_Image_ICCV_2017_paper.pdf.
+
+Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P. Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. In 5th International Conference on Learning Representations, ICLR 2017, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http: //arxiv.org/abs/1409.1556.
+
+Joao V. B. Soares, Jorge J. G. Leandro, Roberto M. Cesar, Herbert F. Jelinek, and Michael J. Cree.˜ Retinal vessel segmentation using the 2-d gabor wavelet and supervised classification. IEEE Trans. Med. Imaging, 25(9):1214–1222, 2006. doi: 10.1109/TMI.2006.879967. URL https: //doi.org/10.1109/TMI.2006.879967.
+
+Joes Staal, Michael D. Abramoff, Meindert Niemeijer, Max A. Viergever, and Bram van Ginneken. \` Ridge-based vessel segmentation in color images of the retina. IEEE Trans. Med. Imaging, 23 (4):501–509, 2004. doi: 10.1109/TMI.2004.825627. URL https://doi.org/10.1109/ TMI.2004.825627.
+
+Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative ¨ models. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016. URL http://arxiv. org/abs/1511.01844.
+
+Dustin Tran, Keyon Vafa, Kumar Krishna Agrawal, Laurent Dinh, and Ben Poole. Discrete flows: Invertible generative models of discrete data. In Deep Generative Models for Highly Structured Data, ICLR 2019 Workshop, New Orleans, Louisiana, United States, May 6, 2019, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rJlo4UIt_E.
+
+Brian L Trippe and Richard E Turner. Conditional density estimation with bayesian normalising flows. 2018. URL https://arxiv.org/abs/1802.04908.
+
+Dmitry Ulyanov, Andrea Vedaldi, and Victor S. Lempitsky. Instance normalization: The missing ingredient for fast stylization. CoRR, abs/1607.08022, 2016. URL http://arxiv.org/ abs/1607.08022.
+
+Rianne van den Berg, Leonard Hasenclever, Jakub M. Tomczak, and Max Welling. Sylvester normalizing flows for variational inference. In Proceedings of the Thirty-Fourth Conference on Uncertainty in Artificial Intelligence, UAI 2018, Monterey, California, USA, August 6-10, 2018, pp. 393–402, 2018.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Koray Kavukcuoglu, Oriol Vinyals, and ¨ Alex Graves. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, pp. 4790–4798, 2016.
+
+Aaron Van Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning, pp. 1747–1756, 2016.
+
+Thang Vu, Tung Luu, and Chang Yoo. Perception-Enhanced Image Super-Resolution via Relativistic Generative Adversarial Networks: Munich, Germany, September 8-14, 2018, Proceedings, Part V, pp. 98–113. 01 2019. ISBN 978-3-030-11020-8. doi: 10.1007/978-3-030-11021-5 7.
+
+Xintao Wang, Ke Yu, Shixiang Wu, Jinjin Gu, Yihao Liu, Chao Dong, Chen Change Loy, Yu Qiao, and Xiaoou Tang. ESRGAN: enhanced super-resolution generative adversarial networks. CoRR, abs/1809.00219, 2018. URL http://arxiv.org/abs/1809.00219.
+
+Zhou Wang, Alan Bovik, Hamid Sheikh, and Eero Simoncelli. Image quality assessment: From error visibility to structural similarity. Image Processing, IEEE Transactions on, 13:600 – 612, 05 2004. doi: 10.1109/TIP.2003.819861.
+
+Saining Xie and Zhuowen Tu. Holistically-nested edge detection. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pp. 1395–1403, 2015. doi: 10.1109/ICCV.2015.164. URL https://doi.org/10.1109/ICCV.2015. 164.
+
+Yuan Yuan, Siyuan Liu, Jiawei Zhang, Yongbing Zhang, Chao Dong, and Liang Lin. Unsupervised image super-resolution using cycle-in-cycle generative adversarial networks. 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 814–81409, 2018.
+
+Roman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparserepresentations. In Proceedings of the 7th International Conference on Curves and Surfaces, pp. 711–730, Berlin, Heidelberg, 2012. Springer-Verlag. ISBN 978-3-642-27412-1. doi: 10.1007/ 978-3-642-27413-8 47. URL https://doi.org/10.1007/978-3-642-27413-8_ 47.
+
+# A ARCHITECTURES
+
+This section describes architecture and optimization details of the conditional normalizing flow network, low-resolution image feature extractor, and shallow convolutional neural network in the conditional coupling layers.
+
+The conditional coupling layer is shown schematically in Figure 6. This shows that conditioned on an input $\mathbf { x }$ , we are able to build a relatively straight-forward invertible mapping between latent representations $\mathbf { z }$ and $\mathbf { y }$ , which have been partitioned into vectors of equal dimension.
+
+![](images/2906cf05b4049b80ff2c97e08543a9486c4b9062c854a0d47dfca1e5c23e7b3a.jpg)  
+Figure 6: The forward and reverse paths of the conditional coupling layer. In our experiments we concatenate an embedding of the conditioning input $\mathbf { x }$ to the latent $\mathbf { z } _ { 1 }$ , which is fed through another neural network to output the affine transformation parameters applied to $\mathbf { z } _ { 0 }$ . This operation is invertible in $\mathbf { z }$ and $\mathbf { y }$ , but not in $\mathbf { x }$ .
+
+Details for the CNFs are given in Table 5 and the details of the individual coupling layers in Table 6 and 7. The architecture of the feature extractor is given in Table 8. The architecture has levels and subflows, following (Dinh et al., 2016; Kingma & Dhariwal, 2018). All networks are optimized using Adam (Kingma & Ba, 2015) for 200000 iterations.
+
+Table 5: Configuration of the CNF architecture for the super-resolution task.   
+
+<table><tr><td>DATASET</td><td>MINIBATCH SIZE</td><td>LEVELS</td><td>SUB-FLOWS</td><td>LEARNING RATE</td></tr><tr><td>ImageNet32</td><td>64</td><td>2</td><td>8</td><td>0.0001</td></tr><tr><td>ImageNet64</td><td>64</td><td>2</td><td>8</td><td>0.0001</td></tr><tr><td>DRIVE</td><td>2</td><td>2</td><td>2</td><td>0.001</td></tr></table>
+
+Table 6: Architecture details for a single coupling layer in the super resolution task. The variable $c _ { \mathrm { o u t } }$ denotes the number of output channels. The first two convolutional layers are followed by a ReLU activation.   
+
+<table><tr><td>LAYER</td><td>INTERMEDIATE CHANNELS</td><td>KERNEL SIZE</td></tr><tr><td>Conv2d</td><td>512</td><td>3×3</td></tr><tr><td>Conv2d</td><td>512</td><td>1×1</td></tr><tr><td>Conv2d</td><td>Cout</td><td>3×3</td></tr></table>
+
+Table 7: Architecture details for a single coupling layer in the DRIVE segmentation task. The variable $c _ { \mathrm { o u t } }$ denotes the number of output channels for the . The first two convolutional layers are followed by a ReLU activation.   
+
+<table><tr><td>LAYER</td><td>INTERMEDIATECHANNELS</td><td>KERNEL SIZE</td></tr><tr><td>Conv2d</td><td>32</td><td>3×3</td></tr><tr><td>InstanceNorm2d</td><td>32</td><td>-</td></tr><tr><td>ReLU</td><td>-</td><td>1</td></tr><tr><td>Conv2d</td><td>Cout</td><td>3×3</td></tr></table>
+
+Table 8: Architecture details for the conditioning network in the super-resolution task. Residualin-residual denseblocks Wang et al. (2018) are utilized. The channel growth is adjusted so that the CNF and the factorized baseline have an equal number of parameters.   
+
+<table><tr><td>MODEL TYPE</td><td>RRDB BLOCKS</td><td></td><td>CHANNEL GROWTH|CONTEXT CHANNELS</td></tr><tr><td>CNF</td><td>16</td><td>32</td><td>128</td></tr><tr><td>Factorized LL</td><td>16</td><td>55</td><td>128</td></tr></table>
+
+# B CONDITIONAL IMAGE GENERATION
+
+In this section, larger versions of the ImageNet64 samples are provided, sampled at different temperatures $\tau$ .
+
+![](images/0a1b755d79f462b7cefbe91d4b81893d50e8c7073b998c76ea0071da28ab93dc.jpg)  
+Figure 7: Super resolution results CNF trained on Imagenet64 sampled at temperature $\tau = 0$
+
+![](images/3257972e069822bca22a6c7f5cbca32b0cdb3c594c59cdf3b43540caa1ed417e.jpg)  
+Figure 8: Super resolution results for the CNF trained on Imagenet64 sampled at $\tau = 0 . 5$
+
+![](images/fd08e3c4f413073f337e8705bf075013fd0c3aff5e295b95f859bf009f1238ad.jpg)  
+Figure 9: Super resolution results for the CNF trained on Imagenet64 sampled at $\tau = 0 . 8$

parse/train/rJg3zxBYwH/rJg3zxBYwH_content_list.json

@@ -0,0 +1,1854 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING LIKELIHOODS WITH CONDITIONAL NORMALIZING FLOWS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            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,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Normalizing Flows (NFs) are able to model complicated distributions $p _ { Y } ( y )$ with strong inter-dimensional correlations and high multimodality by transforming a simple base density $p _ { Z } ( z )$ through an invertible neural network under the change of variables formula. Such behavior is desirable in multivariate structured prediction tasks, where handcrafted per-pixel loss-based methods inadequately capture strong correlations between output dimensions. We present a study of conditional normalizing flows (CNFs), a class of NFs where the base density to output space mapping is conditioned on an input $\\mathbf { X }$ , to model conditional densities $p _ { Y \\mid X } ( y | x )$ . CNFs are efficient in sampling and inference, they can be trained with a likelihood-based objective, and CNFs, being generative flows, do not suffer from mode collapse or training instabilities. We provide an effective method to train continuous CNFs for binary problems and in particular, we apply these CNFs to super-resolution and vessel segmentation tasks demonstrating competitive performance on standard benchmark datasets in terms of likelihood and conventional metrics. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning conditional distributions $p _ { Y | X } ( \\mathbf { y } | \\mathbf { x } )$ is one of the oldest problems in machine learning. When the output $\\mathbf { y }$ is high-dimensional this is a particularly challenging task, and the practitioner is left with many design choices. Do we factorize the conditional? If not, do we model correlations with, say, a conditional random field (Prince, 2012)? Do we use a unimodal distribution? How fat should the tails be? Do we use an explicit likelihood at all, or use implicit methods (Mohamed & Rezende, 2015) such as a GAN (Goodfellow et al., 2014)? Do we quantize the output? Ideally, the practitioner should not have to make design choices at all, and the distribution should be learned from the data. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the field of density estimation normalizing flows (NFs) are a relatively new family of models (Rezende & Mohamed, 2015). NFs model complicated high dimensional marginal distributions $p _ { Y } ( \\mathbf { y } )$ by transforming a simple base distribution or prior $p _ { Z } ( \\mathbf { z } )$ through a learnable, invertible mapping $f _ { \\phi }$ and then applying the change of variables formula. NFs are efficient in inference and sampling, are able to learn inter-dimensional correlations and multi-modality, and they are exact likelihood models, amenable to gradient-based optimization. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Flow-based generative models (Dinh et al., 2016) are generally trained on the image space, and are in some cases computationally efficient in both the forward and inverse direction. These are advantageous over other likelihood based methods because $i _ { , }$ ) sampling is efficient opposed to autoregressive models (Van Oord et al., 2016), and $i i$ ) flows admit exact likelihood optimization in contrast with variational autoencoders (Kingma & Welling, 2014). ",
+        "bbox": [
+            174,
+            742,
+            823,
+            811
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conditional random fields directly model correlations between pixels, and have been fused with deep learning (Chen et al., 2016). However, they require the practitioner to choose which pixels have pairwise interactions. Another approach uses adversarial training (Goodfellow et al., 2014). A downside is that the training procedure can be unstable and they are difficult to evaluate quantitatively. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose to learn the likelihood of conditional distributions with few modeling choices using Conditional Normalizing Flows (CNFs). CNFs can be harnessed for conditional distributions $p _ { Y | X } ( \\mathbf { y } | \\mathbf { x } )$ ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "by conditioning the prior and the invertible mapping on the input x. In particular, we apply conditional flows to super-resolution (Wang et al., 2018) and vessel segmentation (Staal et al., 2004). We evaluate their performance gains on multivariate prediction tasks along side architecturally-matched factored baselines by comparing likelihood and application specific evaluation metrics. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            326,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following, we present the relevant background material on normalizing flows and structured prediction. This section covers the change of variables formula, invertible modules, variational dequantization and conventional likelihood optimization. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NORMALIZING FLOWS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            372,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A standard NF in continuous space is based on a simple change of variables formula. Given two spaces of equal dimension $\\mathcal { Z }$ and $\\mathcal { V }$ ; a once-differentiable, parametric, bijective1 mapping $f _ { \\phi } : \\mathcal { V } $ $\\mathcal { Z }$ , where $\\phi$ are the parameters of $f$ ; and a prior distribution $p _ { Z } ( \\mathbf { z } )$ , we can model a complicated distribution $p _ { Y } ( \\mathbf { y } )$ as ",
+        "bbox": [
+            173,
+            294,
+            825,
+            351
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7036992575acd5e1200fcc3a38b41ba09b6ad4580fe60482f5c9e193539a34c7.jpg",
+        "text": "$$\np _ { Y } ( \\mathbf { y } ) = p _ { Z } ( f _ { \\phi } ( \\mathbf { y } ) ) \\left. \\frac { \\partial f _ { \\phi } ( \\mathbf { y } ) } { \\partial \\mathbf { y } } \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            353,
+            606,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The term $| \\partial f _ { \\phi } ( \\mathbf { y } ) / \\partial \\mathbf { y } |$ is the Jacobian determinant of $f _ { \\phi }$ , evaluated at $\\mathbf { y }$ and it accounts for volume changes induced by $f _ { \\phi }$ . The transformation $f _ { \\phi }$ introduces correlations and multi-modality in $p _ { Y }$ . The main challenge in the field of normalizing flows is designing the transformation $f _ { \\phi }$ . It has to be $i ,$ bijective, $i i _ { . }$ ) have an efficient and tractable Jacobian determinant, iii) be from a ‘flexible’ model class. In addition, $i \\nu _ { . }$ ) for fast sampling the inverse needs to be efficiently computable. Below we briefly state which invertible modules are used in our architectures, obeying the aforementioned points. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Coupling layers Affine coupling layers (Dinh et al., 2016) are invertible, nonlinear layers. They work by splitting the input $\\mathbf { z }$ into two components $\\mathbf { z } _ { 0 }$ and $\\mathbf { z } _ { 1 }$ and nonlinearly transforming $\\mathbf { z } _ { 0 }$ as a function of $\\mathbf { z } _ { 1 }$ , before reconcatenating the result. If ${ \\bf z } = [ { \\bf z } _ { 0 } , { \\bf z } _ { 1 } ]$ and $\\mathbf { y } = [ \\mathbf { y } _ { 0 } , \\mathbf { y } _ { 1 } ]$ this is ",
+        "bbox": [
+            176,
+            502,
+            825,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bebdfe9f23a2905951991a8339bcd5b58bc56777346c8ebfffd6bfa93bee2726.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { \\mathbf { y } _ { 0 } = s ( \\mathbf { z } _ { 1 } ) \\cdot \\mathbf { z } _ { 0 } + t ( \\mathbf { z } _ { 1 } ) \\qquad } & & { \\mathbf { z } _ { 0 } = ( \\mathbf { z } _ { 0 } - t ( \\mathbf { y } _ { 1 } ) ) / s ( \\mathbf { y } _ { 1 } ) } \\\\ & { \\mathbf { y } _ { 1 } = \\mathbf { z } _ { 1 } \\qquad } & & { \\mathbf { z } _ { 1 } = \\mathbf { y } _ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            547,
+            728,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Where the scale $s ( \\cdot )$ and translation $t ( \\cdot )$ functions can be any function, typically implemented with a CNN. Similar conditioning with normalizing flows has been done in previous works by Mohamed & Rezende (2015) and Kingma et al. (2016b). ",
+        "bbox": [
+            174,
+            585,
+            825,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Invertible $\\textbf { 1 x 1 }$ Convolutions Proposed in Kingma & Dhariwal (2018), invertible $1 \\times 1$ convolutions help mix information across channel dimensions. We implement them as regular $1 \\times 1$ convolutions and for the inverse, we convolve with the inverse of the kernel. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Squeeze layers Squeeze layers (Dinh et al., 2016) are used to compress the spatial resolution of activations. These also help with increasing spatial receptive field of pixels in the deeper activations. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Split Prior Split priors (Dinh et al., 2016) work by spliting a set of activations $\\mathbf { z }$ into two components $\\mathbf { z } _ { 0 }$ and $\\mathbf { z } _ { 1 }$ . We then condition $\\mathbf { z } _ { 1 }$ on $\\mathbf { z } _ { 0 }$ using a simple base density e.g. $p ( \\mathbf { z } _ { 1 } | \\mathbf { z } _ { 0 } ) =$ $\\mathbf { \\bar { \\mathcal { N } } } ( \\mathbf { z } _ { 1 } ; \\mu ( \\mathbf { z } _ { 0 } ) , \\sigma ^ { 2 } ( \\mathbf { z } _ { 0 } ) )$ , where $\\mu ( \\cdot )$ and $\\sigma ^ { 2 } ( \\cdot )$ are neural networks. The component $\\mathbf { z } _ { 0 }$ can be modeled by further flow layers. This prior, is useful for modeling hierarchical correlations between dimensions, and also helps reduce computation, since $\\mathbf { z } _ { 0 }$ is reduced in size. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Variational dequantization When modeling discrete data, Theis et al. (2016) introduced the concept of dequantization. For this, they modeled the probability mass function over $\\mathbf { y }$ as a latent variable model ",
+        "bbox": [
+            173,
+            827,
+            825,
+            868
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5893facc344b69d339884288e9a3dd38942be78703c2aec6fa9a0591a50456f.jpg",
+        "text": "$$\nP _ { \\mathrm { m o d e l } } ( \\mathbf { y } ) = \\int _ { \\mathcal { V } } P ( \\mathbf { y } | \\mathbf { v } ) p ( \\mathbf { v } ) \\mathrm { d } \\mathbf { v } = \\int _ { \\mathcal { V } } p ( \\mathbf { y } , \\mathbf { v } ) \\mathrm { d } \\mathbf { v }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            868,
+            663,
+            902
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the latent variables $\\textbf { v } \\in { \\mathcal { V } }$ are continuous-valued. This is a convenient model to use, since the marginal $p ( \\mathbf { v } )$ , living on a continuous sample space, can be modelled with a continuous NF. The distribution $P ( \\mathbf { y } | \\mathbf { v } )$ is known as the quantizer and is typically an indicator function $P ( \\mathbf { y } | \\mathbf { v } ) = \\mathbb { I } [ \\mathbf { v } \\in$ $\\mathbf { y } + [ 0 , 1 ) ^ { D } ]$ . Other works (Hoogeboom et al., $2 0 1 9 \\mathrm { a }$ ; Tran et al., 2019) directly model $P _ { \\mathrm { m o d e l } } ( \\mathbf { y } )$ with a discrete-valued flow, but these are known to be difficult to optimize. As an extension of dequantization, Ho et al. (2019) introduced a variational distribution $\\bar { \\bf q } ( { \\bf v } | { \\bf y } )$ , called a dequantizer, and write a lower bound on the data log-likelihood using Jensen’s inequality as follows ",
+        "bbox": [
+            173,
+            102,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7bc96d773b6f38d9250ca973a49fd1d44e2b5ac5bfc3f16b80b0f7827d5f760.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\log P _ { \\mathrm { m o d e l } } ( \\mathbf { y } ) = \\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\log \\displaystyle \\int p ( \\mathbf { y } , \\mathbf { v } ) \\mathrm { d } \\mathbf { v } } \\\\ & { \\qquad = \\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\log \\displaystyle \\int \\frac { q ( \\mathbf { v } | \\mathbf { y } ) } { q ( \\mathbf { v } | \\mathbf { y } ) } p ( \\mathbf { y } , \\mathbf { v } ) \\mathrm { d } \\mathbf { v } \\geq \\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\int q ( \\mathbf { v } | \\mathbf { y } ) \\log \\displaystyle \\frac { p ( \\mathbf { y } , \\mathbf { v } ) } { q ( \\mathbf { v } | \\mathbf { y } ) } \\mathrm { d } \\mathbf { v } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            208,
+            767,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Noting that the joint $p ( \\mathbf { y } , \\mathbf { v } ) = \\mathbb { I } [ \\mathbf { v } \\in \\mathbf { y } + [ 0 , 1 ) ^ { D } ] p ( \\mathbf { v } )$ , we see that the dequantizer distribution $q ( \\mathbf { v } | \\mathbf { y } )$ must be defined such that $\\mathbf { v } \\in \\mathbf { y } + [ 0 , 1 ) ^ { D }$ , otherwise $p ( \\mathbf { y } , \\mathbf { v } ) = 0$ and the lower-bound is undefined. Restricting $q ( \\mathbf { v } | \\mathbf { y } )$ to satisfy this condition, results in the following variational dequantization bound ",
+        "bbox": [
+            176,
+            282,
+            823,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5743de617a8072ac2e0a189a3464df35bff58a1ce296a8a343f1b5e5a8c4dc66.jpg",
+        "text": "$$\n\\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\log P _ { \\mathrm { m o d e l } } ( \\mathbf { y } ) \\geq \\mathbb { E } _ { P _ { \\mathrm { d a t a } } ( \\mathbf { y } ) } \\int q ( \\mathbf { v } | \\mathbf { y } ) \\log \\frac { p ( \\mathbf { v } ) } { q ( \\mathbf { v } | \\mathbf { y } ) } \\mathrm { d } \\mathbf { v } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            344,
+            694,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 STRUCTURED PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            393,
+            398,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Structured prediction tasks such as image segmentation or super-resolution, can be probabilistically framed as learning an unknown target distribution $p ^ { * } ( \\mathbf { y } \\vert \\mathbf { x } )$ , with an input $\\mathbf { x } \\in \\mathcal { X }$ and a target $\\mathbf { y } \\in \\mathcal { V }$ . In practice with deep learning models, the unknown distribution is often learned by a factored model: ",
+        "bbox": [
+            174,
+            420,
+            823,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7815807a3f3469484febf3715d3534e54217ecf52a7c6b4c301788a9ff0273c7.jpg",
+        "text": "$$\np ( \\mathbf { y } | \\mathbf { x } ) = \\prod _ { d = 1 } ^ { D } p ( y _ { d } | \\mathbf { x } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            468,
+            575,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { d }$ represents the dth dimension of y. Several loss-based optimization methods are a special case of this factored model. The mean squared error is equivalent to a product of normal distributions with equal and fixed standard deviation. Other examples are: cross entropy, equivalent to a product of log categorical distributions, and binary cross entropy, equivalent to a product of log Bernoulli distributions. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With factorized independent likelihoods, individual dimensions of y are assumed to be conditionally independent. As a result, sampling leads to results with uncorrelated noise over the output dimensions. In the literature, a fix for this problem is to visualize the mode of the distribution and interpret that as a prediction. However, because the likelihood was optimized assuming a conditionally independent noise distribution, these modes tend to be blurry and lack crisp details. ",
+        "bbox": [
+            173,
+            594,
+            825,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            282,
+            702
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we present our main innovations. i) learning conditional likelihoods using CNFs and $i i$ ) a variational dequantization framework for binary random variables. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 CONDITIONAL NORMALIZING FLOWS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            477,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose to learn conditional likelihoods using conditional normalizing flows for complicated target distributions in multivariate prediction tasks. Take an input $\\mathbf { x } \\in \\mathcal { X }$ and a regression target $\\mathbf { y } \\in \\mathcal { V }$ . We learn a complicated distribution $p _ { Y | X } ( \\mathbf { y } | \\mathbf { x } )$ using a conditional prior $p _ { Z | X } ( \\mathbf { z } | \\mathbf { x } )$ and a mapping $f _ { \\phi } : \\mathcal { V } \\times \\mathcal { X } \\to \\mathcal { Z }$ , which is bijective in $\\mathcal { V }$ and $\\mathcal { Z }$ . The likelihood of this model is: ",
+        "bbox": [
+            173,
+            790,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/554fa0db53062c2d368377938d089582b6109ba3a57780be5f706b97e63fc090.jpg",
+        "text": "$$\np _ { Y | X } ( \\mathbf { y } | \\mathbf { x } ) = p _ { Z | X } ( \\mathbf { z } | \\mathbf { x } ) \\left| \\frac { \\partial \\mathbf { z } } { \\partial \\mathbf { y } } \\right| = p _ { Z | X } ( f _ { \\phi } ( \\mathbf { y } , \\mathbf { x } ) | \\mathbf { x } ) \\left| \\frac { \\partial f _ { \\phi } ( \\mathbf { y } , \\mathbf { x } ) } { \\partial \\mathbf { y } } \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            854,
+            717,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notice that the difference between Equations 1 and 7 is that all distributions are conditional and the flow has a conditioning argument of $\\mathbf { x }$ . ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The generative process from x to $\\mathbf { y }$ (shown in Figure 1) can be described by first sampling $\\mathbf { z } \\sim$ $p _ { Z | X } ( \\mathbf { z } | \\mathbf { x } )$ from a simple base density with its parameters conditioned on $\\mathbf { x }$ (for us this is a diagonal Gaussian) and then passing it through a sequence of bijective mappings $f _ { \\phi } ^ { - 1 } ( \\mathbf { z } ; \\mathbf { x } )$ . This allows for modelling multimodal conditional distributions in y, which is typically uncommon. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the training procedure, the process runs in reverse. We begin with label $\\mathbf { y }$ and conditioning input $\\mathbf { x }$ . We ‘flow’ the label back through $f _ { \\phi }$ to yield $\\mathbf { z } = f _ { \\phi } ( \\mathbf { y } ; \\mathbf { x } )$ , and then we evaluate the log-likelihood of the parameters of the prior, given this transformed label $\\mathbf { z }$ . The flow and prior parameters can be optimized using stochastic gradient descent and training in minibatches in the usual fashion. Note that this style of training a conditional density model $p _ { Y | X } ( \\mathbf { y } | \\mathbf { x } )$ differs fundamentally from traditional models, because we compute the log-likelihood in $\\mathbf { z }$ -space and not y-space. As a result, we are not biasing our results with an arbitrary choice of output-space likelihood or in the case of this paper, handcrafted image loss. Instead, one could interpret this method as learning the correlational and multimodal structure of the likelihood or simply put loss-learning. ",
+        "bbox": [
+            174,
+            171,
+            549,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d00c1a305b002fe4da20995d0fabb8d03ca5c203d3362bd2c40e5bad8b0f3e7.jpg",
+        "image_caption": [
+            "Figure 1: Diagram of our model in the train and sampling phases. Solid lines represent deterministic mappings and dashed lines represent sampling. The conditioning variable enters the network in base density $p ( \\mathbf { z } | \\mathbf { x } )$ and the bijective mappings $f ( \\mathbf { y } , \\mathbf { x } )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            562,
+            186,
+            823,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Conditional modules In our work, the conditioning is introduced in the prior, the split priors, and the affine coupling modules. For the prior, we set the mean and variance as functions of $\\mathbf { x }$ . For the split prior, we add $\\mathbf { x }$ as a conditoning argument to the conditional $p ( \\mathbf { z } _ { 1 } | \\mathbf { z } _ { 0 } , \\mathbf { x } )$ . And for the affine coupling layers, we pass $\\mathbf { x }$ to the scale and translation networks so that ",
+        "bbox": [
+            176,
+            407,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2432f77e6296154216b836b4d881c98255c92bbd5f2cdbc54dc9ba9937557734.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { C o n d i t i o n a l ~ P r i o r } \\qquad p ( \\mathbf { z } | \\mathbf { x } ) = \\mathcal { N } ( \\mathbf { z } ; \\mu ( \\mathbf { x } ) , \\sigma ^ { 2 } ( \\mathbf { x } ) ) } \\\\ & { \\mathrm { C o n d i t i o n a l ~ S p l i t ~ P r i o r } \\quad p ( \\mathbf { z } _ { 1 } | \\mathbf { z } _ { 0 } , \\mathbf { x } ) = \\mathcal { N } ( \\mathbf { z } _ { 1 } ; \\mu ( \\mathbf { z } _ { 0 } , \\mathbf { x } ) , \\sigma ^ { 2 } ( \\mathbf { z } _ { 0 } , \\mathbf { x } ) ) } \\\\ & { \\mathrm { C o n d i t i o n a l ~ C o u p l i n g } \\quad \\mathbf { y } _ { 0 } = s ( \\mathbf { z } _ { 1 } , \\mathbf { x } ) \\cdot \\mathbf { z } _ { 0 } + t ( \\mathbf { z } _ { 1 } , \\mathbf { x } ) ; \\qquad \\mathbf { y } _ { 1 } = \\mathbf { z } _ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            472,
+            730,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In practice these functions are implemented using deep neural networks. First the conditioning term $\\mathbf { x }$ is transformed into a rich representation $\\mathbf { h } = g ( \\mathbf { x } )$ using a large network $g$ . Subsequently, each function in the flow is applied to a concatenation $[ \\cdot , \\cdot ]$ of $\\mathbf { h }$ and the relevant part of $\\mathbf { z }$ . For example, the translation of a conditional coupling is computed as $t ( \\mathbf { z } _ { 1 } , \\mathbf { x } ) = \\mathbf { N N } ( [ \\mathbf { z } _ { 1 } , \\mathbf { h } ] )$ . ",
+        "bbox": [
+            176,
+            529,
+            825,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 VARIATIONAL DEQUANTIZATION FOR BINARY RANDOM VARIABLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            687,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We generalize the variational dequantization scheme for the binary setting. Let $\\mathbf { y } \\in \\{ 0 , 1 \\} ^ { D }$ be a multivariate binary random variable and $\\mathbf { v } \\in \\mathbb { R } ^ { D }$ its dequantized representation. In Ho et al. (2019) the bound is not guaranteed to be tight, since there is a domain mismatch in the support of $p ( \\mathbf { v } )$ and the variational dequantizer $q ( \\mathbf { v } | \\mathbf { y } )$ . Technically, if $p ( \\mathbf { v } )$ is modeled as a bijective mapping from a Gaussian distribution where the mapping only has finite volume changes, then the support of $p ( \\mathbf { v } )$ is unbounded. On the otherhand, the support of the dequantizer is bounded and so we have to redefine either the dequantizer to map to all of $\\mathbb { R } ^ { D }$ or restrict the support of the flow to a bounded volume inside $\\mathbb { R } ^ { D }$ . We resolve this by dequantizing with half-infinite noise, where ",
+        "bbox": [
+            173,
+            626,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3dcf5000ee068c5360fa1025803f9b79d3eea096990484a6e972a440540fa3ac.jpg",
+        "text": "$$\n\\mathbf { v } | \\mathbf { y } , \\mathbf { z } = 0 . 5 + \\mathrm { s i g n } ( \\mathbf { y } - 0 . 5 ) \\cdot \\mathrm { s o f t p l u s } ( \\mathrm { N N } ( \\mathbf { z } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            741,
+            658,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The softplus guarantees that samples from the neural network NN are only positive. If $\\mathbf { y }$ is 1, the term $\\mathrm { s i g n } ( \\mathbf { y } - 0 . 5 )$ outputs positive-valued noise and if $\\mathbf { y }$ is 0 the noise is negative-valued. ",
+        "bbox": [
+            173,
+            761,
+            828,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            344,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Normalizing flows were originally introduced to machine learning to learn a flexible variational posterior, a conditional distribution, in VAEs (Rezende & Mohamed, 2015; Kingma et al., 2016a; van den Berg et al., 2018). Flow-based generative models (Dinh et al., 2016; Papamakarios et al., 2017; Huang et al., 2018; Kingma & Dhariwal, 2018; Hoogeboom et al., 2019b; Grathwohl et al., 2019; Cao et al., 2019; Chen et al., 2019) are typically trained directly in the data space. Several of these are designed to be fast to invert, which makes them suitable for drawing samples after training. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Different versions and applications of conditional normalizing flows include Agrawal & Dukkipati (2016) who utilize flows in the decoder of Variational AutoEncoders Kingma & Welling (2014), which are conditioned on the latent variable. Trippe & Turner (2018) who utilize conditional flows for prediction problems in a Bayesian framework for density estimation. Atanov et al. (2019) introduce a semi-conditional flow that provides an efficient way to learn from unlabeled data for semisupervised classification problems. Very recently, Ardizzone et al. (2019) have proposed conditional flow-based generative models for image colorization, which differs from our work in training objective, architecture and applicability to binary segmentation. Autoregressive models (Van Oord et al., 2016) have also been studied for conditional image generation van den Oord et al. (2016) but are generally slow to sample from. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Adversarial methods (Goodfellow et al., 2014) have widely been applied to (conditional) image density modeling tasks (Vu et al., 2019; Sajjadi et al., 2017b; Yuan et al., 2018; Mechrez et al., 2018), because they tend to generate high-fidelity images. Disadvantages of adversarial methods are that they can be complicated to train, and it is difficult to obtain likelihoods. For this reason, it can be hard to assess whether they are overfitting or generalizing. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            326,
+            357
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we explain our experiments into super-resolution and vessel segmentation. All models were implemented using the PyTorch framework. ",
+        "bbox": [
+            176,
+            375,
+            823,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 SINGLE IMAGE SUPER RESOLUTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            465,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Single Image Super Resolution (SISR) methods aims to find a high resolution image $x _ { h r }$ given a single (downsampled) low resolution image $x _ { l r }$ . Framing this problem as learning a likelihood, we utilize a CNF to learn the distribution $p ( x _ { h r } | x _ { l r } )$ . To compare our method we also train a factorized baseline likelihood model with comparable architectures and parameter budget. The factorized baseline uses a product of discretized logistic distributions (Kingma et al., 2016a; Salimans et al., 2017). All methods are compared on negative $\\log _ { 2 }$ -likelihood if available, which has the information theoretic interpretation bits per dimensions. In addition, we evaluate using SSIM (Wang et al., 2004) and PSNR metrics. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details The flow is based on the (Dinh et al., 2016; Kingma & Dhariwal, 2018) multi-scale architectures. Each step of flow consists of $K$ subflows and $L$ levels. One subflow consists of an activation normalization, $1 \\times 1$ convolution, and our conditional coupling layer. After completing a level, half of the representation is factored-out and modeled using our conditional split prior. After all levels have been completed, our conditional prior is used to model the final part of the latent variable. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The conditioning variable $x _ { l r }$ is transformed into the feature representation h using Residual-inResidual Dense Block (RRDB) architecture (Wang et al., 2018), consisting of 16 residual-in-residual blocks. To match the parameter budget, the channel growth is 55 for the baseline and the growth is 32 for the CNF. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data The models are trained on natural image datasets, Imagenet32 and Imagenet64 (Chrabaszcz et al., 2017). Since the dataset has no test set, we use its validation images as a test set. For validation we take 10000 images from the train images. The performance is always reported on the test set unless specified otherwise. We evaluate our models on widely used benchmark datasets Set5 (Bevilacqua et al., 2012), Set14 (Zeyde et al., 2012) and BSD100 (Huang et al., 2015). At test time, we pad the test images with zeros at right and bottom so that they are square and compatible with squeeze layers. When evaluating on SSIM and PSNR, we can extract the patch with the exact image shape. For all datasets the LR images are obtained using MATLABs bicubic kernel function with reducing aliasing artifacts following Wang et al. (2018). For these experiments, the pixel values are dequantized by adding uniform noise (Theis et al., 2016). ",
+        "bbox": [
+            174,
+            739,
+            825,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training Settings We train on ImageNet32 and ImageNet64 for 200, 000 iterations with mini batches of size 64, and a learning rate of 0.0001 using the Adam optimizer (Kingma & Ba, 2015). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/968b128bcb0c0904815de5b4636633af6dac527cda75f1e445b409699c0fcf5b.jpg",
+        "image_caption": [
+            "Figure 2: Super resolution results on the Imagenet64 test data. Samples are taken from the CNF $x _ { h r } \\sim p ( x _ { h r } | x _ { l r } )$ and the mode is visualized for the factorized baseline model. Best viewed electronically. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            823,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The high-resolution image $x _ { h r }$ either the original $3 2 \\times 3 2$ or $6 4 \\times 6 4$ original input images. The flow architecture is build with $L = 2$ levels and $K = 8$ . ",
+        "bbox": [
+            174,
+            315,
+            823,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1.1 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            359,
+            320,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section the performance of CNFs for SISR is compared against a baseline likelihood model on ImageNet32 and ImageNet64. Their performance measured in $\\log _ { 2 }$ -likelihood (bits per dimension) is shown in Table 1, which show that the CNF outperforms the factorized baseline in likelihood. Recall that the baseline model is factorized and conditionally independent. These results indicate that it is advantageous to capture the correlations and multi-modality present in the data. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            454
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d38232654bdbbfd11a456af93a0e48b5ee651904fc5bcf891b6a3afaa8a205e5.jpg",
+        "table_caption": [
+            "Table 1: Comparison of likelihood learning with CNFs and factorized discrete baseline on ImageNet32 and ImageNet64 measured in bits per dimensions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>CNF</td><td>factorized LL</td></tr><tr><td>ImageNet32</td><td>3.01</td><td>4.00</td></tr><tr><td>ImageNet64</td><td>2.90</td><td>3.61</td></tr></table>",
+        "bbox": [
+            364,
+            506,
+            632,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Super resolution samples $x _ { h r } \\sim p ( x _ { h r } | x _ { l r } )$ from the Imagenet64 test data are shown in Figure 2. The distribution mode of the factorized baseline is displayed in Figure 2 panel c). We show that the baseline is able to learn a relationship between conditioning variable $\\mathbf { x }$ and $\\mathbf { y }$ , but lacks crisp details. The super-resolution images from the CNF are shown in panel b). Notice there are more high-frequency components modelled, for instance in grass and in hairs. Following Kingma & Dhariwal (2018), we sample from the base distributions with a temperature $\\tau$ of 0.8 to achieve the best perceptual quality for the distribution learned by the CNF. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As there are no standard metric for measuring perceptual quality, we measure performance results on PSNR and SSIM between our predicted image and the ground truth image in Table 2. We compare CNFs to other state-of-the-art per-pixel loss based methods and the factorized baseline for a $2 \\mathbf { x }$ upsampling task on standard super-resolution benchmarks. If available, we report negative $\\log _ { 2 ^ { - } }$ likelihood (bpd) (computed as an average over 1000 randomly cropped $1 2 8 \\mathrm { ~ x ~ } 1 2 8$ patches). Note that without any hyperparameter tuning or compositional loss weighting, as is typical in SISR, the CNF performs competitively with state-of-the-art super-resolution methods by simply optimizing the likelihood. The SSIM scores for the baseline perform on par or better than the adversarial methods and the CNF on all benchmarks. On PSNR scores however, the CNF beats the factorized discrete baseline. Samples shown in Figure 3 show that the CNF predictions have more fine grained texture details. Comparing this finding with the baseline that outperforms every method on SSIM, show that metrics can be misleading. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notice how samples from a independent factorized likelihood model have a lot of color noise, whereas samples from the CNF do not have such problems. Increasing temperature increases highlevel detail, where we find that $\\tau = 0 . 5$ strikes a balance between noise smoothing and detail. This can be attributed to the property of flows to model pixel correlations among output dimensions for high-dimensional data such as images. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5602ea26bc9f0019bce5ce039c4e3071ca127744d2404a6971011ac9cc775f23.jpg",
+        "image_caption": [
+            "Figure 3: Conditional samples from the CNF (ours) for sampling temperatures $\\{ 0 . , 0 . 5 , 1 . 0 \\}$ and the factorized discrete baseline for $2 \\mathbf { x }$ upscaling. Conditioning image is a baboon from Set14 test set. Both models were trained on ImageNet64. Best viewed electronically. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            823,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c532409d5f9005d84432d217c4ef6396c06f517490bbb717dae5d8d8fa4a2431.jpg",
+        "table_caption": [
+            "Table 2: CNF compared to factorized discrete baseline and adversarial, pixel-wise methods (Dong et al., 2015; Sajjadi et al., 2017a; Prez-Pellitero et al., 2016) based on negative $\\log _ { 2 }$ -likelihood (bits per dimension or bpd), PSNR, SSIM and for $2 \\mathbf { x }$ upscaling. Our methods were trained on ImageNet64. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>Set5</td><td colspan=\"5\">Set14</td><td>BSD100</td><td></td></tr><tr><td>Model Type</td><td>bpd</td><td>PSNR</td><td>SSIM 1</td><td>bpd</td><td>PSNR</td><td>SSIM</td><td>bpd</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td>-</td><td>33.7</td><td>0.930</td><td>-</td><td>30.2</td><td>0.869</td><td>1</td><td>29.6</td><td>0.843</td></tr><tr><td>SRCNN</td><td>1</td><td>36.7</td><td>0.954</td><td>1</td><td>32.4</td><td>0.906</td><td>1</td><td>31.4</td><td>0.888</td></tr><tr><td>PSyCO</td><td>1</td><td>36.9</td><td>0.956</td><td>-</td><td>32.6</td><td>0.898</td><td>1</td><td>31.4</td><td>0.890</td></tr><tr><td>ENet</td><td>1</td><td>37.3</td><td>0.958</td><td>1</td><td>33.3</td><td>0.915</td><td>1</td><td>32.0</td><td>0.898</td></tr><tr><td>LL Baseline</td><td>2.34</td><td>32.5</td><td>0.958</td><td>3.23</td><td>31.0</td><td>0.917</td><td>3.20</td><td>30.6</td><td>0.900</td></tr><tr><td>CNF (ours)</td><td>2.11</td><td>36.2</td><td>0.957</td><td>2.51</td><td>32.5</td><td>0.911</td><td>2.33</td><td>31.4</td><td>0.893</td></tr></table>",
+        "bbox": [
+            173,
+            391,
+            821,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 VESSEL SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            569,
+            383,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Vessel segmentation is an important, long-standing, medical imaging problem, where we seek to segment blood vessels from pictures of the retina (the back of the eye). This is a difficult task, because the vessels are thin and of varying thickness. A likelihood function used in segmentation is ",
+        "bbox": [
+            173,
+            599,
+            826,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/64404a415db694e85d9227c5b4fd54d66608ebbee408c1463360b6822919ce1f.jpg",
+        "image_caption": [
+            "Figure 4: Example of retinal segmentations using DRIU, our likelihood baseline trained with the same loss, and our CNF. For the CNF, the mean of 100 samples is visualized. Notice that our segmentations more accurately capture the vessel width, which is overdilated in the DRIU and factored models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            672,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6c6811f6732fcf8e7af3849b9391a8999fe2366d17bdfc5608fbbb332a3d7eb5.jpg",
+        "table_caption": [
+            "Table 3: Numerical results on the DRIVE dataset. We see that the CNF is in the range of the SOTA model DRIU. SE: Structured Forests (Dollar & Zitnick, 2013), LD: Line Detector (Ricci & Perfetti, ´ 2007), Wavelets (Soares et al., 2006), Human (Staal et al., 2004), HED: Holistic Edge Detector (Xie & Tu, 2015), KB: Kernel Boost Becker et al. (2013), $N ^ { 4 }$ : $N ^ { 4 }$ Fields (Ganin & Lempitsky, 2014), DRIU: Deep Retinal Image Understanding (Maninis et al., 2016). Our answers are shown in mean ± 1std form, where statistics are taken over 5 runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>SE</td><td>LD</td><td>Wavelets</td><td>Human</td><td>HED</td><td>KB</td><td>N4</td><td>DRIU</td><td>Factored (ours)</td><td>CNF Uniform (Ours)</td><td>CNF (ours)</td></tr><tr><td>bpd</td><td></td><td></td><td></td><td>■</td><td>=</td><td>=</td><td></td><td></td><td>0.0647 ± 0.0015</td><td>0.3366 ± 0.0290</td><td>0.0254± 0.0008</td></tr><tr><td>F-Score</td><td>0.658</td><td>0.692</td><td>0.762</td><td>0.791</td><td>0.794</td><td>0.800</td><td>0.805</td><td>0.821</td><td>0.815 ± 0.001</td><td>0.762 ± 0.002</td><td>0.819 ± 0.001</td></tr></table>",
+        "bbox": [
+            176,
+            195,
+            823,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "a weighted Bernoulli distribution ",
+        "bbox": [
+            173,
+            260,
+            393,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2941e0fa60e747be02afea1233001f45cb5791567c8dc5a821ed218a2ff3028.jpg",
+        "text": "$$\n\\mathcal { L } = \\prod _ { j } \\frac { p _ { j } ^ { \\beta \\cdot y _ { j } } ( 1 - p _ { j } ) ^ { ( 1 - \\beta ) \\cdot ( 1 - y _ { j } ) } } { p _ { j } ^ { \\beta } + ( 1 - p _ { j } ) ^ { 1 - \\beta } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            280,
+            616,
+            325
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { j } = p ( y _ { j } = 1 | \\mathbf { x } )$ is the prediction probability that pixel $y _ { j }$ is positive (vessel class) and $\\beta$ is a class balancing constant set to $\\sim 1 0 \\%$ for us. This loss function is preferred, because it accounts for the apparent class imbalance in the ratio of vessels to background. In practice, the numerator of this likelihood is used as a loss function and the normalizer is ignored. The resulting loss is called a weighted cross-entropy. In our experiments we train using the weighted cross-entropy (as in the literature), but we report likelihood values including the normalizer, for a meaningful comparison. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            417
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dataset and comparisons We test on the DRIVE database Staal et al. (2004) consisting of $5 8 4 \\times$ 565, 8-bit RGB images, split into 20 train, and 20 test images. To compare against other methods, we plot precision-recall curves, report the maximum F-score along each curve (shown as a dot in the graph), report the bits per dimension, and plot distributions in PR-space. The main CNN-based contenders are Deep Retinal Image Understanding (DRIU) (Maninis et al., 2016) and HolisticallyNested Edge Detection (HED) (Xie & Tu, 2015), both of which are instances of Deeply-Supervised Nets (Lee et al., 2015). The main difference between DRIU and HED is that DRIU is pretrained on ImageNet Krizhevsky et al. (2012); whereas, HED is not. Other competing methods are reported with results cited from (Maninis et al., 2016). For fairness, we also train a model which we call the likelihood baseline, which uses the exact same architecture as the flow but run a feedforward model and trained with the weighted Bernoulli loss. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            585
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementation The flow is identical to the flow used in the previous section, with some key differences. i) instead of activation normalization, we use instance normalization (Ulyanov et al., 2016), ii) the conditional affine coupling layers do not contain a scaling component $s ( \\cdot )$ but just the translation $t ( \\cdot )$ , hence it is volume preserving, and iii) we train using variational dequantization. Since the data is binary-valued, we dequantize according to the Flow $^ { + + }$ scheme of Ho et al., modified to binary variables (see Section 3.2), using a CNF at just a single scale for the dequantizer. The CNF is conditioned on resolution-matched features extracted from a VGG-like network Simonyan & Zisserman (2015). This model is composed of blocks of the form block $=$ [InstanceNorm, ReLU, conv], and $2 \\mathbf { x } 2$ max-pooling layer, shown in Table 4. All filter sizes are $3 { \\tt X } 3$ . The outputs are at layers 4 and 7. These are used to condition the resolution 512 and 256 levels of the CNF, respectively. ",
+        "bbox": [
+            174,
+            603,
+            612,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1589cc26343e700cb779ff78a621169e5778c08b02c0e4960128025060235400.jpg",
+        "table_caption": [
+            "Table 4: Feature extractor architecture for retinal vessel segmentation. RES. abbreviates resolution. Outputs are at layer 4 and 7. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>LAYER</td><td rowspan=1 colspan=1>TYPE</td><td rowspan=1 colspan=1>RES.</td></tr><tr><td rowspan=1 colspan=1>01</td><td rowspan=1 colspan=1>inputblock</td><td rowspan=1 colspan=1>10241024</td></tr><tr><td rowspan=1 colspan=1>234</td><td rowspan=1 colspan=1>max-poolblockblock</td><td rowspan=1 colspan=1>512512512</td></tr><tr><td rowspan=3 colspan=1>567</td><td rowspan=3 colspan=1>max-poolblockblock</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>256</td></tr></table>",
+        "bbox": [
+            625,
+            671,
+            831,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training/test settings We train using the Adam optimizer at learning rate 0.001, and a minibatch size of 2 for 2000 epochs. All images are padded to $1 0 2 4 \\mathrm { x } 1 0 2 4$ pixels, so that they are compatible with squeeze layers. We use $3 6 0 ^ { \\circ }$ rotation augmentation, isotropic scalings in the range [0.8, 1.2], and shears drawn from a normal distribution with standard deviation $1 0 ^ { \\circ }$ . At test time we draw samples from our model and compare those against the groundtruth labels. This contrasts with other methods, that measure labels against thresholded versions of a factorized predictive distribution. To create the PR curve in Figure 5 we take the average of 100 samples and threshold the resulting map (example shown in Figure 4). While crude, this mean image is useful in defining a PR-curve, since there is not great topology change between samples. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Evaluation The results of our experiments are shown in Table 3 and Figure 5, with a visualization in Figure 4. We see in the table that the CNF trained with our binary dequantization achieves the best bits per dimension, with comparable F-score to the state of the art model (DRIU), but our model does not require pretraining on ImageNet. Interestingly, we found training a flow with uniform dequantization slightly unstable and the results were far from satisfactory. In the PR-curve Figure 5, we show a comparable curve for our binary dequantized CNF to the DRIU model. These results, however, say nothing about the calibration of the probability outputs, but just that the various probability predictions are well ranked. To gain an insight into the calibration of the probabilities, we measure the distribution of precision and recall values for point samples drawn from all models, including a second human grader, present in the original DRIVE dataset. We synthesized samples from factored distributions (all except ours and ‘human’), by sampling images from a factored Bernoulli with mean as the soft image. We see the results in the right hand plot of Figure 5, which shows that while the other CNN-based methods such as DRIU or HED have good precision, they suffer in term of recall. On the other hand, the CNF drops in precision a little bit, but makes up for this in terms of high recall, with a PR distribution overlapping the human grader. This indicates that the CNF has learned a well-calibrated distribution, compared to the baseline methods. Further evidence of this is seen in the visualization in Figure 4, which shows details from the predicted means (soft images). This shows that the DRIU and likelihood baseline overdilate segmentations and the CNF does not. This can be explained from the fact that in the weighted Bernoulli it is cheaper to overdilate than to underdilate. Since the CNF contains no handcrafted loss function, we circumvent this pathology. ",
+        "bbox": [
+            173,
+            171,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/258f0bc2d5bbcbd0d20d8a912778473082ec933769f1dc7b2d5eb4d68b02c020.jpg",
+        "image_caption": [
+            "Figure 5: Here we show two visualizations of the same data. LEFT: We show the PR-curves generated from a sweeping threshold on soft images output by each listed method. Maximal F-scores for each curve are shown as circles with the green lines indicating constant F-score. We see that our method beats all traditional methods and is on par with DRIU, which unlike us was pretrained on Imagenet. RIGHT: We show a scatter plot in PR-space of samples drawn from each model. To draw samples from the all factored models, we sample images from a factored Bernoulli with a mean as the soft image. We see that the DRIU and HED models, while having good precision, have poor recall in this regime. This indicates that while the output of their networks produce a good ranking of probabilities, the values of the probabilities are poorly calibrated. For us, we drop in precision slightly, but gain greatly in terms of recall, indicating that our samples are drawn from a better calibrated distribution, overlapping significantly with the Human distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            479,
+            810,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose to learn likelihoods of conditional distributions using conditional normalizing flows. In this setting, supervised prediction tasks can be framed probabilistically. In addition, we propose a generalization of variational dequantization for binary random variables, which is useful for binary segmentation problems. Experimentally we show competitive performance with competing methods in the domain of super-resolution and binary image segmentation. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            224,
+            285,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Siddharth Agrawal and Ambedkar Dukkipati. Deep variational inference without pixel-wise reconstruction. CoRR, abs/1611.05209, 2016. ",
+        "bbox": [
+            174,
+            250,
+            823,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lynton Ardizzone, Carsten Luth, Jakob Kruse, Carsten Rother, and Ullrich K ¨ othe. Guided im- ¨ age generation with conditional invertible neural networks. CoRR, abs/1907.02392, 2019. URL http://arxiv.org/abs/1907.02392. ",
+        "bbox": [
+            173,
+            287,
+            821,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrei Atanov, Alexandra Volokhova, Arsenii Ashukha, Ivan Sosnovik, and Dmitry Vetrov. Semiconditional normalizing flows for semi-supervised learning. 05 2019. ",
+        "bbox": [
+            171,
+            339,
+            823,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Carlos J. Becker, Roberto Rigamonti, Vincent Lepetit, and Pascal Fua. Supervised feature learning for curvilinear structure segmentation. In Medical Image Computing and Computer-Assisted Intervention - MICCAI 2013 - 16th International Conference, Nagoya, Japan, September 22-26, 2013, Proceedings, Part I, pp. 526–533, 2013. doi: 10.1007/978-3-642-40811-3\\ 66. URL https://doi.org/10.1007/978-3-642-40811-3_66. ",
+        "bbox": [
+            173,
+            378,
+            826,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marco Bevilacqua, Aline Roumy, Christine Guillemot, and Marie-Line Alberi-Morel. Lowcomplexity single-image super-resolution based on nonnegative neighbor embedding. In BMVC, 2012. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicola De Cao, Wilker Aziz, and Ivan Titov. Block neural autoregressive flow. In Proceedings of the Thirty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI 2019, Tel Aviv, Israel, July 22-25, 2019, pp. 511, 2019. ",
+        "bbox": [
+            174,
+            512,
+            826,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016. URL http://arxiv.org/abs/1606. 00915. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ricky T. Q. Chen, Jens Behrmann, David Duvenaud, and Jorn-Henrik Jacobsen. Residual flows for ¨ invertible generative modeling. CoRR, abs/1906.02735, 2019. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the CIFAR datasets. CoRR, abs/1707.08819, 2017. URL http://arxiv.org/ abs/1707.08819. ",
+        "bbox": [
+            173,
+            670,
+            826,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real NVP. CoRR, abs/1605.08803, 2016. URL http://arxiv.org/abs/1605.08803. ",
+        "bbox": [
+            171,
+            723,
+            823,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Piotr Dollar and C. Lawrence Zitnick. Structured forests for fast edge detection. In ´ IEEE International Conference on Computer Vision, ICCV 2013, Sydney, Australia, December 1-8, 2013, pp. 1841–1848, 2013. doi: 10.1109/ICCV.2013.231. URL https://doi.org/10.1109/ ICCV.2013.231. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Image super-resolution using deep convolutional networks. CoRR, abs/1501.00092, 2015. URL http://arxiv.org/abs/ 1501.00092. ",
+        "bbox": [
+            173,
+            829,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin and Victor S. Lempitsky. $\\mathrm { N } ^ { 4 }$ -fields: Neural network nearest neighbor fields for image transforms. CoRR, abs/1406.6558, 2014. URL http://arxiv.org/abs/1406. 6558. ",
+        "bbox": [
+            176,
+            880,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Proceedings of the 27th International Conference on Neural Information Processing Systems - Volume 2, NIPS’14, pp. 2672–2680, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/ citation.cfm?id=2969033.2969125. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Will Grathwohl, Ricky T. Q. Chen, Jesse Bettencourt, Ilya Sutskever, and David Duvenaud. FFJORD: free-form continuous dynamics for scalable reversible generative models. In 7th International Conference on Learning Representations, ICLR 2019, 2019. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            227
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho, Xi Chen, Aravind Srinivas, Yan Duan, and Pieter Abbeel. Flow $^ { + + }$ : Improving flowbased generative models with variational dequantization and architecture design. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019. ",
+        "bbox": [
+            171,
+            238,
+            825,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho, Xi Chen, Aravind Srinivas, Yan Duan, and Pieter Abbeel. Flow $^ { + + }$ : Improving flowbased generative models with variational dequantization and architecture design. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 2722–2730, 2019. URL http://proceedings.mlr.press/ v97/ho19a.html. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emiel Hoogeboom, Jorn W. T. Peters, Rianne van den Berg, and Max Welling. Integer discrete flows and lossless compression. CoRR, abs/1905.07376, 2019a. URL http://arxiv.org/abs/ 1905.07376. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emiel Hoogeboom, Rianne van den Berg, and Max Welling. Emerging convolutions for generative normalizing flows. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 2019b. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            468
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chin-Wei Huang, David Krueger, Alexandre Lacoste, and Aaron C. Courville. Neural autoregressive flows. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , pp. 2083–2092, 2018. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Huang, A. Singh, and N. Ahuja. Single image super-resolution from transformed self-exemplars. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5197–5206, June 2015. doi: 10.1109/CVPR.2015.7299156. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. 2015. ",
+        "bbox": [
+            174,
+            587,
+            736,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. In Proceedings of the 2nd International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            641
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016a. URL http://arxiv.org/abs/1606. 04934. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016b. URL http://arxiv.org/abs/1606. 04934. ",
+        "bbox": [
+            176,
+            705,
+            823,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 10236– 10245. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8224-glow-generative-flow-with-invertible-1x1-convolutions.pdf. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            829
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems 2012. Proceedings of a meeting held December 3-6, 2012, Lake Tahoe, Nevada, United States., pp. 1106–1114, 2012. URL http://papers.nips.cc/paper/ 4824-imagenet-classification-with-deep-convolutional-neural-networks. ",
+        "bbox": [
+            174,
+            840,
+            864,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen-Yu Lee, Saining Xie, Patrick W. Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. In Proceedings of the Eighteenth International Conference on Artificial Intelligence and Statistics, AISTATS 2015, San Diego, California, USA, May 9-12, 2015, 2015. URL http://proceedings.mlr.press/v38/lee15a.html. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kevis-Kokitsi Maninis, Jordi Pont-Tuset, Pablo Andres Arbel´ aez, and Luc Van Gool. Deep reti-´ nal image understanding. In Medical Image Computing and Computer-Assisted Intervention - MICCAI 2016 - 19th International Conference, Athens, Greece, October 17-21, 2016, Proceedings, Part II, pp. 140–148, 2016. doi: 10.1007/978-3-319-46723-8\\ 17. URL https: //doi.org/10.1007/978-3-319-46723-8_17. ",
+        "bbox": [
+            173,
+            170,
+            825,
+            241
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Roey Mechrez, Itamar Talmi, Firas Shama, and Lihi Zelnik-Manor. Learning to maintain natural image statistics. CoRR, abs/1803.04626, 2018. URL http://arxiv.org/abs/1803.04626. ",
+        "bbox": [
+            169,
+            251,
+            823,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shakir Mohamed and Danilo J. Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Proceedings of the 28th International Conference on Neural Information Processing Systems - Volume 2, NIPS’15, pp. 2125–2133, Cambridge, MA, USA, 2015. MIT Press. URL http://dl.acm.org/citation.cfm?id ${ . } = { }$ 2969442.2969477. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            348
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Papamakarios, Theo Pavlakou, and Iain Murray. Masked autoregressive flow for density estimation. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 2338–2347. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6828-masked-autoregressive-flow-for-density-estimation.pdf. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            429
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simon JD Prince. Computer vision: models, learning, and inference. Cambridge University Press, 2012. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eduardo Prez-Pellitero, Jordi Salvador, Javier Ruiz-Hidalgo, and Bodo Rosenhahn. Manifold span reduction for super resolution. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR)., June 2016. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 1530–1538, 2015. URL http://proceedings.mlr.press/ v37/rezende15.html. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            588
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Elisa Ricci and Renzo Perfetti. Retinal blood vessel segmentation using line operators and support vector classification. IEEE Trans. Med. Imaging, 26(10):1357–1365, 2007. doi: 10.1109/TMI. 2007.898551. URL https://doi.org/10.1109/TMI.2007.898551. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            641
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. S. M. Sajjadi, B. Scholkopf, and M. Hirsch. EnhanceNet: Single image super- ¨ resolution through automated texture synthesis. In Proceedings IEEE International Conference on Computer Vision (ICCV), pp. 4501–4510, Piscataway, NJ, USA, October 2017a. IEEE. URL http://openaccess.thecvf.com/content_ICCV_2017/papers/ Sajjadi_EnhanceNet_Single_Image_ICCV_2017_paper.pdf. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            723
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. S. M. Sajjadi, B. Scholkopf, and M. Hirsch.¨ EnhanceNet: Single image superresolution through automated texture synthesis. In Proceedings IEEE International Conference on Computer Vision (ICCV), pp. 4501–4510, Piscataway, NJ, USA, October 2017b. IEEE. URL http://openaccess.thecvf.com/content_ICCV_2017/papers/ Sajjadi_EnhanceNet_Single_Image_ICCV_2017_paper.pdf. ",
+        "bbox": [
+            173,
+            733,
+            825,
+            804
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P. Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. In 5th International Conference on Learning Representations, ICLR 2017, 2017. ",
+        "bbox": [
+            176,
+            814,
+            823,
+            857
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http: //arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joao V. B. Soares, Jorge J. G. Leandro, Roberto M. Cesar, Herbert F. Jelinek, and Michael J. Cree.˜ Retinal vessel segmentation using the 2-d gabor wavelet and supervised classification. IEEE Trans. Med. Imaging, 25(9):1214–1222, 2006. doi: 10.1109/TMI.2006.879967. URL https: //doi.org/10.1109/TMI.2006.879967. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Joes Staal, Michael D. Abramoff, Meindert Niemeijer, Max A. Viergever, and Bram van Ginneken. \\` Ridge-based vessel segmentation in color images of the retina. IEEE Trans. Med. Imaging, 23 (4):501–509, 2004. doi: 10.1109/TMI.2004.825627. URL https://doi.org/10.1109/ TMI.2004.825627. ",
+        "bbox": [
+            173,
+            170,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative ¨ models. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016. URL http://arxiv. org/abs/1511.01844. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dustin Tran, Keyon Vafa, Kumar Krishna Agrawal, Laurent Dinh, and Ben Poole. Discrete flows: Invertible generative models of discrete data. In Deep Generative Models for Highly Structured Data, ICLR 2019 Workshop, New Orleans, Louisiana, United States, May 6, 2019, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rJlo4UIt_E. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Brian L Trippe and Richard E Turner. Conditional density estimation with bayesian normalising flows. 2018. URL https://arxiv.org/abs/1802.04908. ",
+        "bbox": [
+            173,
+            372,
+            823,
+            402
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Andrea Vedaldi, and Victor S. Lempitsky. Instance normalization: The missing ingredient for fast stylization. CoRR, abs/1607.08022, 2016. URL http://arxiv.org/ abs/1607.08022. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            454
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Rianne van den Berg, Leonard Hasenclever, Jakub M. Tomczak, and Max Welling. Sylvester normalizing flows for variational inference. In Proceedings of the Thirty-Fourth Conference on Uncertainty in Artificial Intelligence, UAI 2018, Monterey, California, USA, August 6-10, 2018, pp. 393–402, 2018. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            522
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Koray Kavukcuoglu, Oriol Vinyals, and ¨ Alex Graves. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, pp. 4790–4798, 2016. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aaron Van Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning, pp. 1747–1756, 2016. ",
+        "bbox": [
+            171,
+            599,
+            825,
+            630
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thang Vu, Tung Luu, and Chang Yoo. Perception-Enhanced Image Super-Resolution via Relativistic Generative Adversarial Networks: Munich, Germany, September 8-14, 2018, Proceedings, Part V, pp. 98–113. 01 2019. ISBN 978-3-030-11020-8. doi: 10.1007/978-3-030-11021-5 7. ",
+        "bbox": [
+            174,
+            640,
+            823,
+            683
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xintao Wang, Ke Yu, Shixiang Wu, Jinjin Gu, Yihao Liu, Chao Dong, Chen Change Loy, Yu Qiao, and Xiaoou Tang. ESRGAN: enhanced super-resolution generative adversarial networks. CoRR, abs/1809.00219, 2018. URL http://arxiv.org/abs/1809.00219. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            736
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Alan Bovik, Hamid Sheikh, and Eero Simoncelli. Image quality assessment: From error visibility to structural similarity. Image Processing, IEEE Transactions on, 13:600 – 612, 05 2004. doi: 10.1109/TIP.2003.819861. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            789
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie and Zhuowen Tu. Holistically-nested edge detection. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pp. 1395–1403, 2015. doi: 10.1109/ICCV.2015.164. URL https://doi.org/10.1109/ICCV.2015. 164. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            856
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuan Yuan, Siyuan Liu, Jiawei Zhang, Yongbing Zhang, Chao Dong, and Liang Lin. Unsupervised image super-resolution using cycle-in-cycle generative adversarial networks. 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 814–81409, 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Roman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparserepresentations. In Proceedings of the 7th International Conference on Curves and Surfaces, pp. 711–730, Berlin, Heidelberg, 2012. Springer-Verlag. ISBN 978-3-642-27412-1. doi: 10.1007/ 978-3-642-27413-8 47. URL https://doi.org/10.1007/978-3-642-27413-8_ 47. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            354,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "This section describes architecture and optimization details of the conditional normalizing flow network, low-resolution image feature extractor, and shallow convolutional neural network in the conditional coupling layers. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            176
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The conditional coupling layer is shown schematically in Figure 6. This shows that conditioned on an input $\\mathbf { x }$ , we are able to build a relatively straight-forward invertible mapping between latent representations $\\mathbf { z }$ and $\\mathbf { y }$ , which have been partitioned into vectors of equal dimension. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            226
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/2906cf05b4049b80ff2c97e08543a9486c4b9062c854a0d47dfca1e5c23e7b3a.jpg",
+        "image_caption": [
+            "Figure 6: The forward and reverse paths of the conditional coupling layer. In our experiments we concatenate an embedding of the conditioning input $\\mathbf { x }$ to the latent $\\mathbf { z } _ { 1 }$ , which is fed through another neural network to output the affine transformation parameters applied to $\\mathbf { z } _ { 0 }$ . This operation is invertible in $\\mathbf { z }$ and $\\mathbf { y }$ , but not in $\\mathbf { x }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            236,
+            746,
+            314
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Details for the CNFs are given in Table 5 and the details of the individual coupling layers in Table 6 and 7. The architecture of the feature extractor is given in Table 8. The architecture has levels and subflows, following (Dinh et al., 2016; Kingma & Dhariwal, 2018). All networks are optimized using Adam (Kingma & Ba, 2015) for 200000 iterations. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            450
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf99a8501d282fbd1540158999e38e2cbf793fb01f9b611d6047db5e941bbd34.jpg",
+        "table_caption": [
+            "Table 5: Configuration of the CNF architecture for the super-resolution task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DATASET</td><td>MINIBATCH SIZE</td><td>LEVELS</td><td>SUB-FLOWS</td><td>LEARNING RATE</td></tr><tr><td>ImageNet32</td><td>64</td><td>2</td><td>8</td><td>0.0001</td></tr><tr><td>ImageNet64</td><td>64</td><td>2</td><td>8</td><td>0.0001</td></tr><tr><td>DRIVE</td><td>2</td><td>2</td><td>2</td><td>0.001</td></tr></table>",
+        "bbox": [
+            222,
+            491,
+            774,
+            559
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/04d534c32137a63aeae64bd988806712a39468cfccb699e0d8547138059a74a1.jpg",
+        "table_caption": [
+            "Table 6: Architecture details for a single coupling layer in the super resolution task. The variable $c _ { \\mathrm { o u t } }$ denotes the number of output channels. The first two convolutional layers are followed by a ReLU activation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>INTERMEDIATE CHANNELS</td><td>KERNEL SIZE</td></tr><tr><td>Conv2d</td><td>512</td><td>3×3</td></tr><tr><td>Conv2d</td><td>512</td><td>1×1</td></tr><tr><td>Conv2d</td><td>Cout</td><td>3×3</td></tr></table>",
+        "bbox": [
+            299,
+            152,
+            697,
+            223
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/999132a82e222546bf3a135fec88309ef6e000a401bdaeb0a8e8b3b3d8e593e7.jpg",
+        "table_caption": [
+            "Table 7: Architecture details for a single coupling layer in the DRIVE segmentation task. The variable $c _ { \\mathrm { o u t } }$ denotes the number of output channels for the . The first two convolutional layers are followed by a ReLU activation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LAYER</td><td>INTERMEDIATECHANNELS</td><td>KERNEL SIZE</td></tr><tr><td>Conv2d</td><td>32</td><td>3×3</td></tr><tr><td>InstanceNorm2d</td><td>32</td><td>-</td></tr><tr><td>ReLU</td><td>-</td><td>1</td></tr><tr><td>Conv2d</td><td>Cout</td><td>3×3</td></tr></table>",
+        "bbox": [
+            269,
+            296,
+            728,
+            382
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/07e7fb84eddb5f5af9fa3c750f8428430a0dbea1e936aad457a39ea09268ea26.jpg",
+        "table_caption": [
+            "Table 8: Architecture details for the conditioning network in the super-resolution task. Residualin-residual denseblocks Wang et al. (2018) are utilized. The channel growth is adjusted so that the CNF and the factorized baseline have an equal number of parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MODEL TYPE</td><td>RRDB BLOCKS</td><td></td><td>CHANNEL GROWTH|CONTEXT CHANNELS</td></tr><tr><td>CNF</td><td>16</td><td>32</td><td>128</td></tr><tr><td>Factorized LL</td><td>16</td><td>55</td><td>128</td></tr></table>",
+        "bbox": [
+            214,
+            457,
+            784,
+            512
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B CONDITIONAL IMAGE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            508,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In this section, larger versions of the ImageNet64 samples are provided, sampled at different temperatures $\\tau$ . ",
+        "bbox": [
+            174,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a1b755d79f462b7cefbe91d4b81893d50e8c7073b998c76ea0071da28ab93dc.jpg",
+        "image_caption": [
+            "Figure 7: Super resolution results CNF trained on Imagenet64 sampled at temperature $\\tau = 0$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            176,
+            725,
+            527
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/3257972e069822bca22a6c7f5cbca32b0cdb3c594c59cdf3b43540caa1ed417e.jpg",
+        "image_caption": [
+            "Figure 8: Super resolution results for the CNF trained on Imagenet64 sampled at $\\tau = 0 . 5$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            116,
+            725,
+            464
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd08e3c4f413073f337e8705bf075013fd0c3aff5e295b95f859bf009f1238ad.jpg",
+        "image_caption": [
+            "Figure 9: Super resolution results for the CNF trained on Imagenet64 sampled at $\\tau = 0 . 8$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            529,
+            725,
+            880
+        ],
+        "page_idx": 17
+    }
+]