Add files using upload-large-folder tool

parse/train/HJNJws0cF7/HJNJws0cF7.md

@@ -0,0 +1,283 @@
+# CONVOLUTIONAL NEURAL NETWORKS COMBINED WITH RUNGE-KUTTA METHODS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+A convolutional neural network for image classification can be constructed mathematically since it can be regarded as a multi-period dynamical system. In this paper, a novel approach is proposed to construct network models from the dynamical systems view. Since a pre-activation residual network can be deemed an approximation of a time-dependent dynamical system using the forward Euler method, higher order Runge-Kutta methods (RK methods) can be utilized to build network models in order to achieve higher accuracy. The model constructed in such a way is referred to as the Runge-Kutta Convolutional Neural Network (RKNet). RK methods also provide an interpretation of Dense Convolutional Networks (DenseNets) and Convolutional Neural Networks with Alternately Updated Clique (CliqueNets) from the dynamical systems view. The proposed methods are evaluated on benchmark datasets: CIFAR-10/100, SVHN and ImageNet. The experimental results are consistent with the theoretical properties of RK methods and support the dynamical systems interpretation. Moreover, the experimental results show that the RKNets are superior to the state-of-the-art network models on CIFAR-10 and on par on CIFAR-100, SVHN and ImageNet.
+
+# 1 INTRODUCTION
+
+Residual Networks (ResNets) which are feed-forward network models with skip connections have achieved great success on several vision benchmarks (He et al., 2016a). Recently, researchers have studied the relation between ResNets and dynamical systems (Liao & Poggio, 2016; E, 2017; Haber et al., 2017; Chang et al., 2018a;b; Lu et al., 2018). Forward Euler method, a first-order RK method, has been employed to explain ResNets with full pre-activation (He et al., 2016b) from the dynamical systems view (Haber et al., 2017; Chang et al., 2018b). Nevertheless, there is no firm evidence to prove that the residual block is just forward Euler method but not any other RK method. We regard the residual mapping as an approximation to the increment in a time-step. The accuracy of the approximation is determined by the structure of the convolutional network. Wide residual network (WRN) (Zagoruyko & Komodakis, 2016) has been proposed to improve the ability of the convolutional subnetwork. However, it is not very efficient only to widen the subnetwork. The new explanation of pre-activation ResNet and its variants which focus on improving residual mapping is one of our contributions.
+
+In addition, some improvements on network architecture based on ordinary differential equations (ODEs) are proposed (Chang et al., 2018a; Lu et al., 2018; Chen et al., 2018). Under the assumption that pre-activation ResNet is forward Euler method, Chang et al. (2018a); Lu et al. (2018) use special linear multi-step methods (LM methods) with low order to construct the network. Chen et al. (2018) utilize a third-party package which offers numerical ODE methods to replace residual block. There is no efficient network architecture for systematic generalization to high order till now. Nevertheless, a higher-order method can achieve a lower truncation error. Since a lower truncation error likely leads to a high accuracy, it is necessary to study an efficient network architecture with a high order.
+
+If the process of image classification is deemed a sequence of time-dependent dynamical systems, there should be a series of ODEs to describe these systems. RK methods are widely-used procedures to solve ODEs in numerical analysis (Butcher, 2008). They are also the building blocks of highorder LM methods. Consequently, these methods can be used to build network models for visual processing.
+
+The neural network community has long been aware of the numerical methods for dynamical systems. Runge-Kutta Neural Network (RKNN) is proposed for identification of unknown dynamical systems in high accuracy (Wang & Lin, 1998), but it has not been used to model the visual system nor been extended to convolutional networks. Moreover, RKNNs adopt a specific RK methods by indicating every coefficient for the RK methods. Thus, it is hard to apply high order RK methods in RKNNs. In addition, the time-step size need to be prespecified. Hence, RKNN cannot be used in tasks where the total time is unknown such as image classification. In contrast, we learn all the coefficients and time-step sizes implicitly by training in order to avoid these difficulties. As a result, one of the major contributions of the paper is a novel and effective neural network architecture inspired by the RK methods.
+
+In order to apply RK methods to the image classification problem, the following assumptions are made throughout the paper. Firstly, the image classification procedure is multi-period and there are transitions between adjacent periods. Secondly, each period is modeled by a time-dependent firstorder dynamical system. Based on these assumptions, a novel network model called the RKNet is proposed.
+
+In an RKNet, a period is composed of iterations of time-steps. A particular RK method is adopted throughout the time-steps in a period to approximate the increment in each step. The increment in each step is broken down to the increments in several stages according to the adopted RK method. Each stage is approximated by a convolutional subnetwork due to the versatility of neural networks on approximation.
+
+Another contribution of this paper is a theoretical interpretation of DenseNets and CliqueNets from the dynamical systems view. The dense connections in DenseNet resemble the relationship among increments in the stages in explicit RK methods (ERK methods). Similarly, the clique blocks in CliqueNets resemble the relationship among increments in the stages in implicit RK methods (IRK methods). Under some conditions, DenseNets and CliqueNets can be formulated as approximating dynamical systems using multi-stage RK methods. We also propose a method to convert a DenseNet to an explicit RKNet (ERKNet) and a method convert a CliqueNet to an implicit RKNet (IRKNet). Furthermore, DenseNets and CliqueNets have only one time-step in each period, whereas RKNets are more general and can have multiple time-steps in each period.
+
+We evaluate the performance of RKNets on benchmark datasets including CIFAR-10, CIFAR100 (Krizhevsky, 2009), SVHN (Netzer et al., 2011) and ILSVRC2012 classification dataset (Russakovsky et al., 2015). Experimental results show that both ERKNets and IRKNets conform to the mathematical properties. Additionally, RKNets achieve higher accuracy than the state-of-the-art network models on CIFAR-10 and comparable accuracy on CIFAR-100, SVHN and ImageNet.
+
+The rest of the paper is organized as follows. The related work is reviewed in Section 2. The architecture of RKNets, the dynamical systems interpretation of DenseNets and CliqueNets, and the conversion from them to RKNets are described in Section 3. The performance of RKNets is evaluated in Section 4. The conclusion and future work is described in Section 5.
+
+# 2 RELATED WORK
+
+ResNets have gained much attention over the past few years since they have obtained impressive performance on many challenging image tasks, such as ImageNet (Russakovsky et al., 2015) and COCO object detection (Lin et al., 2014). ResNets are deep feed-forward networks with the shortcuts as identity mappings. ResNets with pre-activation can be regarded as an unfolded shallow RNN, which implements a discrete dynamical system (Liao & Poggio, 2016). It provides a novel point of view for explaining pre-activation ResNets from dynamical systems view.
+
+Recently, more work has emerged to connect dynamical systems with deep neural networks (E, 2017) or ResNets in particular (Haber et al., 2017; Chang et al., 2018a;b; Li et al., 2018; Long et al., 2018; Lu et al., 2018; Wang et al., 2018; Chen et al., 2018). E (2017) proposes to use continuous dynamical systems as a tool for machine learning. Chang et al. (2018a) propose three reversible architectures based on ResNets and ODE systems. Chang et al. (2018b) propose a novel method for accelerating ResNets training based on the interpretation of ResNets from dynamical systems view (Haber et al., 2017). Li et al. (2018) present a training algorithm which can be used in the context of ResNets. Lu et al. (2018) propose a 2-step architecture based on ResNets. In addition, research combining dynamical system identification and RK methods with neural networks for scientific computing has emerged recently (Raissi et al., 2017a;b; Raissi, 2018), introducing physics informed neural networks with automatic differentiation. Chen et al. (2018) utilize a third-party package which offers some numerical methods to compute the numerical solution in each time-step.
+
+DenseNets (Huang et al., 2017) are the state-of-the-art network models after ResNets. The dense connection is the main difference from the previous models. There are direct connections from a layer to all subsequent layers in a dense block in order to allow better information and gradient flow. There is no interpretation of DenseNets from dynamical systems view yet. CliqueNets (Yang et al., 2018) are the state-of-the-art network models based on DenseNets. They adopt the alternately updated clique blocks to incorporate both forward and backward connections between any two layers in the same block. However, there is no interpretation of CliqueNets from dynamical systems view yet.
+
+Given that the process of image classification is regarded as a sequence of time-dependent dynamical systems, there should be a set of ODEs that describes these systems. Consequently, mathematical tools could be employed to construct network models. RK methods are commonly used to solve ODEs in numerical analysis (Butcher, 2008). Higher order RK methods can achieve lower truncation error. Moreover, these methods are usually the building blocks of high-order LM methods. Therefore, RK methods are ideal tools to construct network models from dynamical systems view.
+
+RK methods have been adopted to construct neural networks, which are known as RKNN, for identification of unknown dynamical systems described by ODEs (Wang & Lin, 1998). In that paper, neural networks are classified into two categories: (1) a network that directly learns the state trajectory of a dynamical system is called a direct-mapping neural network (DMNN); (2) a network that learns the rate of change of system states is called a RKNN. Hence, AlexNet (Krizhevsky et al., 2012), VGGNet (Simonyan & Zisserman, 2015), GoogLeNet (Szegedy et al., 2015) and ResNet (He et al., 2016a) all belong to DMNNs. Specifically, the original ResNet (He et al., 2016a) is a DMNN because of the ReLU layer after the addition operation. As a result, the ResNet building block learns the state trajectory directly, not the rate of change of the system states. On the contrary, a ResNet with pre-activation (He et al., 2016b) is an RKNN.
+
+RKNNs are proposed to eliminate several drawbacks of DMNNs, such as the difficulty in obtaining high accuracy for the multi-step prediction of state trajectories. It has been shown theoretically and experimentally that the RKNN has higher prediction accuracy and better generalization capability than the conventional DMNN (Wang & Lin, 1998).
+
+Therefore, it is reasonable to believe that RK methods can be adopted to design effective network architectures for image classification problems. Additionally, the RK methods might improve the performance of image classification since the convolutional subnetworks are able to approximate the rate of change of the dynamical system states more precisely.
+
+# 3 RKNETS
+
+The introduction to RK methods are in Section 3.1. We describe the overall structure of RKNet in Section 3.2. The structure of subnetwork for increment in each time-step is elaborated on in Section 3.3.
+
+# 3.1 RUNGE-KUTTA METHODS
+
+An initial value problem for a time-dependent first-order dynamical system can be described by the following ODE (Butcher, 2008):
+
+$$
+{ \frac { d { \pmb y } } { d t } } = f \left( t , \pmb y ( t ) \right) , \qquad \pmb y \left( t _ { 0 } \right) = \pmb y _ { 0 } .
+$$
+
+where $\textbf {  { y } }$ is a vector representing the system state. The dimension of $\textbf {  { y } }$ should be equal to the dimension of the dynamical system. The ODE represents the rate of change of the system states. The rate of change is a function of time and the current system state. RK methods utilize the rate of change calculated from the ODE to approximate the increment in each time-step, and then obtain the predicted final state at the end of each step. RK methods are numerical methods originated from
+
+![](images/1e71843579b62c9107ba64a9e8e4f3b1c926584345b9727647f70fab120e78f4.jpg)  
+Figure 1: Architecture of a 3-period RKNet. $\pmb { y } ^ { ( d ) }$ denotes the system state of period $d$ . $\pmb { y } _ { 0 } ^ { ( d ) }$ is the initial state of period $d$ . ${ \pmb y } _ { r } ^ { ( d ) }$ is the final state after $r$ time-steps in period $d , r$ is the total number of time-steps in a period. It can vary in different periods. Period 1 and time-step 1 in it are unfolded as an example. System state changes throughout a period. The final state of a step is estimated as the initial state of this step adding an increment. This operation originates from RK methods. To approximate the increment is the key point in RKNet. The dotted lines are for multiscale feature strategy.
+
+Euler method. There are two types of RK methods: explicit and implicit. Both of them are employed in the RKNet. The family of RK methods is given by the following equations (Sli & Mayers, 2003):
+
+$$
+{ \pmb y } _ { n + 1 } = { \pmb y } _ { n } + h \sum _ { i = 1 } ^ { s } b _ { i } { \pmb z } _ { i } , \qquad t _ { n + 1 } = t _ { n } + h ,
+$$
+
+where
+
+$$
+z _ { i } = f \left( t _ { n } + c _ { i } h , \ y _ { n } + h \sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \right) , \qquad 1 \leq i \leq s .
+$$
+
+In equation 2, ${ \mathbf { } } ^ { \pmb { y } _ { n + 1 } }$ is an approximation of the solution to equation 1 at time $t _ { n + 1 }$ , i.e. $\boldsymbol { y } ( t _ { n + 1 } )$ ; $\scriptstyle { \mathbf { 3 0 } }$ is the input initial value; $\begin{array} { r } { h \sum _ { i = 1 } ^ { \bar { s } } b _ { i } z _ { i } } \end{array}$ is the increment of system state $\textbf {  { y } }$ from $t _ { n }$ to $t _ { n + 1 }$ ; $\textstyle \sum _ { i = 1 } ^ { s } b _ { i } z _ { i }$ is the estimated slope which is the weighted average of the slopes $z _ { i }$ computed in different stages. The positive integer $s$ is the number of $z _ { i }$ , i.e. the number of stages of the RK method. The equation 3 is the general formula of $z _ { i }$ . $h$ is the time-step size which can be adaptive for different time-steps but must be fixed across stages within a time-step.
+
+In numerical analysis, $s$ , $a _ { i j }$ , $b _ { i }$ and $c _ { i }$ in equation 2 and equation 3 need to be prespecified for a particular RK method. These coefficients are displayed in a Butcher tableau. The ERK methods are those methods with $a _ { i j } = 0$ when $1 \leq i \leq j \leq s$ . All the RK methods other than ERK methods are IRK methods. The algebraic relationships of the coefficients have to meet the order conditions to reach the highest possible order. Different RK methods have different truncation errors which are denoted by the order: an order $p$ indicates that the local truncation error is $O ( h ^ { p + 1 } )$ . If a $s$ -stage ERK method has order $p$ , then $s \geq p$ ; if $p \geq 5$ , then $s > p$ (Butcher, 2008). Furthermore, a $s$ -stage IRK method can has order $p = 2 s$ when its coefficients are chosen under some conditions (Butcher, 2008). Therefore, more stages may achieve higher orders, i.e. lower truncation errors. The Euler method is a one-stage first-order RK method with $b _ { 1 } = 1$ and $c _ { 1 } = 0$ . In other words, high-order RK methods can be expected to achieve lower truncation errors than Euler method. Thus, the goal of our proposed RKNets is to improve the classification accuracy by taking advantage of high-order RK methods.
+
+It is necessary to specify $h$ in order to control the error of approximation in common numerical analysis. The varying time-step size can be adaptive to the regions with different rates of change. The truncation error is lower when the $h$ is smaller.
+
+# 3.2 FROM RK METHODS TO RKNETS
+
+There are three components of RKNets: the preprocessor, the multi-periods and the postprocessor. The preprocessor manipulates the raw images and passes the results to the first period. The postprocessor deals with the output from the last period or all the periods while adopting multiscale feature strategy (Yang et al., 2018). Then, it passes the result to the classifier to make a decision. The periods between those two components are divided by the transition layers. These periods can be modeled by time-dependent dynamical systems. Each period of an RKNet is divided into $r$ timesteps as shown in Figure 1. RK methods approximate the final state of every time-step using the rate of change of the system state. Some guiding principles when applying RK methods to RKNets are listed as follows.
+
+Firstly, dimensionality reduction is often carried out to simplify the system identification issue, when the dimension of real dynamical system is too high. The dimension of $\textbf {  { y } }$ in each period in RKNet is predefined as the multiplication of the size of feature map and the number of channels at the beginning of a period. The dimensions of $\textbf {  { y } }$ in the same periods of different RKNets can be different due to various degrees of dimensionality reduction. Nevertheless, the dimension of $\textbf {  { y } }$ is consistent within a period.
+
+Secondly, given that there is no explicit ODE for image classification, a convolutional subnetwork is employed to approximate the increment in each time-step. The number of neurons in each hidden layer can be more than the dimension of $\textbf {  { y } }$ .
+
+Thirdly, the number of stages $s$ in each period is predefined in RKNet but the other coefficients, $a _ { i j }$ $b _ { i }$ and $c _ { i }$ in equation 2 and equation 3 are learned by training. Due to the order conditions (Butcher, 2008), the relationship among the coefficients are more important than the specific value of any individual coefficient. Hence, the coefficients are learned implicitly but not as explicit parameters. The optimal relationship among the coefficients with a highest possible order is obtained after training.
+
+Lastly, the number of time-steps $r$ in each period is predefined in RKNet, but the step size $h$ is learned by training. $n$ in equation 2 and equation 3 is limited to the range $[ 0 , r )$ . The learned $h$ is thus considered adaptive. In theory, the adaptive time-step size can achieve higher accuracy.
+
+A variety of RK methods can be adopted in the different periods of RKNets, but the same RK method is used for all time-steps within one period in an RKNet. The network models are named after the specific method in each period, such as RKNet- $3 \times 2 . 4 \times 1 . 2 \times 5 . 1 \times 1$ . The suffix in the name of an RKNet is composed of several $s \times r$ terms; each stands for the method in corresponding period. The number of such terms equals the total number of periods. $s$ or $r$ can vary in different periods. For example, RKNet- $\cdot 3 { \times } 2 . 4 { \times } 1 . 2 { \times } 5 . 1 { \times } 1$ has four periods: period one has 2 time-steps and each step has 3 stages; period two has 1 time-step and it has 4 stages; period three has 5 time-steps and each step has 2 stages; period four has 1 time-step and it has 1 stage. We use this notation throughout this paper. In addition, ERKNets only adopt ERK methods and IRKNets only adopt IRK methods.
+
+Given an RKNet model, $s$ and $r$ can be modified to construct more variants with the same dimensions in the corresponding periods. In other words, $s$ and $r$ control depth of the network while dimensionality reduction controls the width of the network. More stages, more time-steps and larger dimensions usually lead to higher classification accuracy. However, the complexity of an ODE increases with the increase of dimensions. As a result, the convolutional subnetwork which approximates the increment in a time-step need be more complex for larger dimensions. Hence, the accuracy is also associated with the matching degree of the dimension and the convolutional subnetwork. The unmatched high-dimensional network model may have lower accuracy. Additionally, the training method might affect the classification accuracy too.
+
+# 3.3 ERKNETS AND IRKNETS
+
+In this section, we introduce the architecture of RKNets. As shown in equation 2, the sum of $h b _ { i } z _ { i }$ represents the increment in a time-step. It is crucial to approximate this increment in RKNet. For
+
+![](images/289c04b98656e522707995f6f43d5d3bb5e2b591c63fc7eb12570933a0a3de3f.jpg)  
+Figure 2: Architecture of one time-step in ERKNet using an $s$ -stage ERK method. ${ \bf { { y } } } _ { n }$ is the approximation of $\pmb { y } ( t _ { n } )$ . A dense block grows every $m$ times at a growth rate of $k$ to form a convolutional subnetwork for generating each $h b _ { i } z _ { i }$ . Here, $h$ is time-step size, $b _ { i }$ is coefficient of ERK method, and $z _ { i }$ is the slope of each stage in ERK method. The total number of growth is $m s$ in a dense block in order to generate $h b _ { i } z _ { i }$ for $i = 1$ , . . . , $s$ . An explicit summation layer is added after a dense block to complete a time-step.
+
+the purpose of constructing an RKNet, it is necessary to hide the time-step size and the coefficients in RK methods. $h b _ { i } z _ { i }$ can be described as follows according to equation 3:
+
+$$
+\begin{array} { l } { { \displaystyle h b _ { i } z _ { i } = h b _ { i } f \left( t _ { n } + c _ { i } h , ~ y _ { n } + h \sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \right) } } \\ { { \displaystyle ~ = g _ { i } \left( y _ { n } + h \sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \right) } } \\ { { \displaystyle ~ = F _ { i } \left( y _ { n } , ~ h a _ { i 1 } z _ { 1 } , ~ . . . , ~ h a _ { i s } z _ { s } \right) . } } \end{array}
+$$
+
+The above transformation first changes the explicit dependence on the time in equation 3 to an implicit one. Since the time parameter $t _ { n } + c _ { i } h$ is different for the different stages, it can be absorbed into $g _ { i } ( \cdot )$ , which implicitly depends on time for stage $i$ . Afterward, the summation in the input parameter of $g _ { i } ( \cdot )$ is split into separate terms. $F _ { i } ( \cdot )$ denotes the function of these terms for each stage. We verify that $F _ { i } ( \cdot )$ can equal to $g _ { i } ( \cdot )$ after training by experiment though $F _ { i } ( \cdot )$ is more expressive than $g _ { i } ( \cdot )$ in expression. Additionally, $F _ { i } ( \cdot )$ is more memory efficient than $g _ { i } ( \cdot )$ because of saving the storage for the summation inputted to $g _ { i } ( \cdot )$ .
+
+# 3.3.1 CONNECT ERKNETS WITH DENSENETS
+
+In order to construct ERKNets, $h b _ { i } z _ { i }$ can be described by the equation below, according to equation 4.
+
+$$
+\begin{array} { r l } & { h b _ { i } z _ { i } = e _ { i } \left( { { y } _ { n } } , \ h a _ { i 1 } { { z } _ { 1 } } , \ \ldots , \ h a _ { i ( i - 1 ) } { { z } _ { i - 1 } } \right) } \\ & { \qquad = E _ { i } \left( { { y } _ { n } } , \ h b _ { 1 } { { z } _ { 1 } } , \ \ldots , \ h b _ { i - 1 } { { z } _ { i - 1 } } \right) . } \end{array}
+$$
+
+The above transformation first eliminates $h a _ { i j } z _ { j }$ $( i \leq j )$ from $F _ { i } ( \cdot )$ in equation 4 since $a _ { i j } = 0$ when $1 \leq i \leq j \leq s$ for ERK methods (See 3.1). As a result, $h b _ { i } z _ { i }$ is denoted by a function of $y _ { n }$ and $h a _ { i j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ . It is written as $e _ { i } ( \cdot )$ . After that, adjusting the coefficients of each parameter from $a _ { i j }$ to $b _ { j }$ yields another function $E _ { i } ( \cdot )$ . It is a function of $y _ { n }$ and $h b _ { j } z _ { j }$ for $j = 1 , \ldots , i - 1$ .
+
+If a convolutional subnetwork is adopted to model $E _ { i } ( \cdot )$ in equation 5, the most similar network structure is the dense connections in DenseNets. To be specific, a growth in a dense block concatenates all the preceding layers as the input of convolutional subnetwork just like that $h b _ { i } z _ { i }$ uses $y _ { n }$ and all the increments in preceding stages as the input of $E _ { i } ( \cdot )$ . For the purpose of adopting dense block in ERKNets, the dense blocks must conform to the following rules.
+
+Rule 1 The number of channels of ${ \bf { { y } } } _ { n }$ is in the form of $m k$ , where $m$ and $k$ are positive integers and $k$ is known as the growth rate in DenseNet literature. The dimension of ${ \bf { \nabla } } \pmb { y } _ { n }$ is the multiplication of the size of feature map and $m k$ .
+
+Rule 2 Every $m$ successive growth constructs a convolutional subnetwork for $E _ { i } ( \cdot )$ . Each subnetwork outputs mk channels which are regarded as a group according to the number of channels of ${ \bf { \nabla } } \pmb { y } _ { n }$ . Each convolutional subnetwork concatenates ${ \bf { { y } } } _ { n }$ and all the preceding groups as its input. The $i$ th group generated by the ith subnetwork corresponds to $h b _ { i } z _ { i }$ .
+
+Rule 3 The total number of growth is $m s$ , where $s$ is number of stages of RK methods. Consequently, $s$ groups representing $h b _ { i } z _ { i }$ for $i = 1$ , . . . , $s$ are generated by $s$ convolutional subnetworks modeling $E _ { i } ( \cdot )$ for $i = 1$ , . . . , $s$ successively in a dense block.
+
+Appending to a restricted dense block conforming to the above rules, ${ \bf { \nabla } } \pmb { y } _ { n }$ and the groups $h b _ { i } z _ { i }$ for $i = 1 , \dots , s$ are added to obtain $\mathbf { \nabla } _ { \mathbf { y } _ { n + 1 } }$ according to equation 2. Figure 2 illustrates one time-step of ERKNet.
+
+In DenseNets, every dense block together with part of the subsequent computation can be regarded as a period using a $s$ -stage ERK method with $r = 1$ time-step. The transition layers and the postprocessor contain the summation operation in equation 2. This gives an explanation of DenseNets from the dynamical systems view.
+
+# 3.3.2 CONNECT IRKNETS WITH CLIQUENETS
+
+$h b _ { i } z _ { i }$ for IRK methods can be described by the equation below, according to equation 4.
+
+$$
+\begin{array} { r l } & { h b _ { i } z _ { i } = H _ { i } \left( y _ { n } , \ h b _ { 1 } z _ { 1 } , \ \ldots , \ h b _ { s } z _ { s } \right) } \\ & { \qquad = G _ { i } \left( h b _ { 1 } z _ { 1 } , \ \ldots , \ h b _ { i - 1 } z _ { i - 1 } , \ h b _ { i + 1 } z _ { i + 1 } , \ \ldots , \ h b _ { s } z _ { s } \right) } \\ & { \qquad = I _ { i } \left( h b _ { 1 } z _ { 1 } , \ \ldots , \ h b _ { i - 1 } z _ { i - 1 } , \ v _ { i + 1 } , \ \ldots , \ v _ { s } \right) } \end{array}
+$$
+
+where
+
+$$
+\begin{array} { l } { { \pmb { v } } _ { j } = V _ { j } ( h b _ { j } z _ { j } ) } \\ { = J _ { j } \left( \pmb { y } _ { n } , \ \pmb { v } _ { 1 } , \ \dots , \ \pmb { v } _ { j - 1 } \right) . } \end{array}
+$$
+
+The above transformation first adjusts the coefficients of each parameter of $F _ { i } ( \cdot )$ in equation 4 from $a _ { i j }$ to $b _ { j }$ . It yields another function $H _ { i } ( \cdot )$ . As a result, every $h b _ { i } z _ { i }$ is a function of $y _ { n }$ . Thus, $h b _ { i } z _ { i }$ can be denoted by a function of $h b _ { j } z _ { j }$ for $j = 1 , \ \dots , \ s , \ j \neq i$ . This function is written as $G _ { i } ( \cdot )$ .
+
+Inspired by Newton method which is used to implement IRK methods (Butcher, 2008), $h b _ { i } z _ { i }$ is initialized using all available information firstly and then updated alternately. Given $v _ { j }$ is the initial value of $h b _ { j } z _ { j }$ , the relationship between them is denoted by the function $V _ { j } ( \cdot )$ . Therefore, $h b _ { i } z _ { i }$ can be denoted by a function of $h b _ { j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ and ${ \boldsymbol { v } } _ { j }$ for $j = i \dot { + } 1$ , . . . , $s$ . This function is written as $I _ { i } ( \cdot )$ . It is the update function of $h b _ { i } z _ { i }$ . Since every $h b _ { j } z _ { j }$ is a function of $y _ { n }$ , every ${ \pmb v } _ { j }$ is also a function of $y _ { n }$ . Thus, $v _ { j }$ can be denoted by a function of $y _ { n }$ and $v _ { q }$ for $q = 1$ , . . . , $j - 1$ . This function is written as $J _ { j } ( \cdot )$ . It is the initialization function of $h b _ { j } z _ { j }$ .
+
+The update process is a sequence of iterations till convergence in Newton method. In other words, ${ \pmb v } _ { j }$ is updated for many times to approach $h b _ { j } z _ { j }$ . During updating, $G _ { i } ( \cdot )$ with the biased input is used as the update function since $I _ { i } ( \cdot )$ is unknown. If using convolutional subnetwork to model each $I _ { i } ( \cdot )$ , these functions can be learned under the help of training. As a result, each ${ \boldsymbol { v } } _ { j }$ needs to be updated only once. Therefore, the computational cost is reduced remarkably.
+
+If a convolutional subnetwork is adopted to model $J _ { j } ( \cdot )$ in equation 7 and $I _ { i } ( \cdot )$ in equation 6, the most similar network structure is the clique block in CliqueNets. To be specific, a clique block is composed of Stage-I and Stage-II in CliqueNet literature. Stage-I which initializes all layers in a clique block is regarded as a sequence of $J _ { j } ( \cdot )$ . Then, Stage-II for updating all layers alternately corresponds to all $I _ { i } ( \cdot )$ . In CliqueNet literature, all layers in a clique block except the top layer to be updated are concatenated as the bottom layer, i.e. the input of a convolutional subnetwork for updating. It is just like $I _ { i } ( \cdot )$ uses $h b _ { j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ and ${ \pmb v } _ { j }$ for $j = i + 1$ , . . . , $s$ as input. In order to adopt clique block in IRKNets, the clique blocks must conform to the following rules.
+
+![](images/3964a1541e8814e122044fe8ad72fd24615d1403b7304702d7acbd86036528a0.jpg)  
+Figure 3: Architecture of one time-step in IRKNet using a 3-stage IRK method. ${ \bf { { y } } } _ { n }$ is the approximation of $\pmb { y } ( t _ { n } )$ . A dense block, which is Stage-I of a clique block, grows $k$ channels every time to generate the initial value of each $h b _ { i } z _ { i }$ , written as ${ \mathbf { } } v _ { i }$ . Here, $h$ is time-step size, $b _ { i }$ is coefficient of IRK method, and $z _ { i }$ is the slope of each stage in IRK method. In Stage-II of a clique block, the convolutional subnetwork concatenating the current values of $h b _ { j } z _ { j }$ for $j = 1$ , . . . , 3, $j \neq i$ to update every $h b _ { i } z _ { i }$ alternately. An explicit summation layer is added after a clique block to complete a time-step.
+
+Rule 1 The number of channels of ${ \bf { { y } } } _ { n }$ is $k$ , which is the growth rate in Stage-I since Stage-I is a dense block. The dimension of ${ \bf { \nabla } } \pmb { y } _ { n }$ is the multiplication of the size of feature map and $k$ .
+
+Rule 2 Every growth in Stage-I constructs a convolutional subnetwork. Each subnetwork outputs $k$ channels which are regarded as a group according to the number of channels of ${ \bf { \nabla } } \pmb { y } _ { n }$ . Each convolutional subnetwork concatenates ${ \bf { \nabla } } \pmb { y } _ { n }$ and all the preceding groups as its input. The ith group generated by the ith subnetwork is ${ \mathbf { } } v _ { i }$ .
+
+Rule 3 The total number of growth in Stage-I is $s$ , which is number of stages of RK methods. Consequently, $s$ groups representing ${ \mathbf { } } v _ { i }$ for $i = 1$ , . . . , $s$ are generated by $s$ convolutional subnetworks successively in Stage-I. $s$ should be larger than 1 for updating alternately in Stage-II.
+
+Appending to a restricted clique block conforming to the above rules, ${ \bf { \nabla } } \pmb { y } _ { n }$ and the groups $h b _ { i } z _ { i }$ for $i = 1 , \dots , s$ are added to obtain $\mathbf { \nabla } _ { \mathbf { y } _ { n + 1 } }$ according to equation 2. Figure 3 illustrates one time-step of IRKNet using a 3-stage IRK method as an example.
+
+In CliqueNets, every clique block together with part of the subsequent computation can be regarded as a period using a $s$ -stage IRK method with $r = 1$ time-step. The transition layers and the postprocessor contain the summation operation in equation 2. This gives an explanation of CliqueNets from the dynamical systems view.
+
+# 4 EXPERIMENTS
+
+To verify the theoretical properties of RK methods and evaluate the performance of RKNets on image classification, experiments are conducted using the proposed network architectures. The experimental setup is described in Appendix A. Some extra techniques, including attentional transition, bottleneck and multiscale feature strategy, can be adopted in RKNets following CliqueNets. They are introduced in Appendix B.
+
+Table 1: Test errors of ERKNets and IRKNets, evaluated on CIFAR-10 without data augmentation. The growth rate $k$ is 36 in every period of the RKNets. The times of successive growth in each stage, $m$ , is 1. The multiscale feature strategy is used. All the models are run with batchsize 64.   
+
+<table><tr><td>ERKNet</td><td>FLOPs (G)</td><td>Params (M)</td><td>Error (%)</td><td>IRKNet</td><td>FLOPs (G)</td><td>Params (M)</td><td>Error (%）</td></tr><tr><td>-6×1_6×1.6×1</td><td></td><td>0.74</td><td>7.08</td><td>-3×1_3×1_3×1</td><td>0.38</td><td>0.32</td><td></td></tr><tr><td>-7×1.6×1.6×1</td><td>0.66 0.83</td><td>0.83</td><td>7.02</td><td>-4×1.3×1.3×1</td><td>0.62</td><td>0.40</td><td>7.18 6.89</td></tr><tr><td>-7×1_7×1_6×1</td><td>0.87</td><td>0.91</td><td>6.67</td><td>-4×1_4×1.3×1</td><td>0.68</td><td>0.49</td><td>6.63</td></tr><tr><td>-7×1_7×1_7×1</td><td>0.88</td><td>0.99</td><td>6.61</td><td>-4×1_4×1_4×1</td><td>0.69</td><td>0.57</td><td>6.50</td></tr></table>
+
+Table 2: Test errors evaluated on CIFAR and SVHN. $k$ is growth rate. The multiscale feature strategy is used in RKNets. A and B represent attentional transition and bottleneck respectively. The bottleneck layers which output $k$ channels to the following layers are used in IRKNets. C10 and C100 stand for CIFAR-10 and CIFAR-100 respectively. $\ " + \ "$ indicates standard data augmentation. When data augmentation is not used, dropout layers are added. The values with \* are provided by Huang et al. (2017). The values with $\dagger$ are provided by Kuen et al. (2017). The values with $\star$ are computed by ourselves. FLOPs and Params are calculated on CIFAR-10 or SVHN. RKNets are run with batchsize 32 on CIFAR but run with batchsize 64 on SVHN. Results that outperform all competing methods are bold and the overall best result is blue.   
+
+<table><tr><td>Model</td><td>FLOPs ParamsC10 (G)</td><td>(M)</td><td>(%）</td><td>C10+ (%）</td><td>C100 (%）</td><td>(%）</td><td>C100+ SVHN (%）</td></tr><tr><td>pre-act ResNet (He et al., 2016b)</td><td></td><td>10.2</td><td>10.56*</td><td>4.62</td><td>33.47*</td><td>22.71</td><td></td></tr><tr><td>WRN (Zagoruyko &amp; Komodakis,2016)</td><td>3.10+ 10.49+</td><td>11.0 36.5</td><td></td><td>4.27 4.00</td><td>一 =</td><td>20.43 19.25</td><td>1.54</td></tr><tr><td>DenseNet (Huang et al., 2017)</td><td>14.53* 27.2 10.83* 15.3</td><td></td><td>5.83 5.19</td><td>3.74 3.62</td><td>23.42 19.64</td><td>19.25 17.60</td><td>1.59 1.74</td></tr><tr><td>Hamiltonian (Chang et al.,2018a)</td><td>18.59* 25.6</td><td>1.68</td><td>1</td><td>3.46 5.98</td><td></td><td>17.18</td><td></td></tr><tr><td>LM-architecture (Lu et al., 2018)</td><td></td><td>1.7</td><td></td><td>5.27</td><td>=</td><td>26.11 22.9</td><td></td></tr><tr><td>CliqueNet (Yang et al., 2018)</td><td></td><td>68.8</td><td></td><td>=</td><td>1</td><td>16.79</td><td></td></tr><tr><td></td><td>9.45 10.56*</td><td>10.14 10.48× 5.06</td><td>5.06</td><td></td><td>23.14 21.83</td><td></td><td>1.51 1.64</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=80)</td><td>2.17</td><td>1.40</td><td>5.27</td><td></td><td></td><td></td><td></td></tr><tr><td>IRKNet-5×1_5×1_5×1-A (k=80)</td><td>5.44</td><td></td><td></td><td>4.23</td><td>24.35</td><td>21.77</td><td>1.74</td></tr><tr><td></td><td></td><td>4.37</td><td>■</td><td>=</td><td>1</td><td>=</td><td>1.63</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=150)</td><td>7.62</td><td>4.87</td><td>4.60</td><td>3.60</td><td>21.39</td><td>19.42</td><td>1.64</td></tr><tr><td>IRKNet-6×1_6×1_6×1-A (k=80)</td><td>7.92</td><td>6.28</td><td></td><td></td><td>=</td><td></td><td>1.52</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=180)</td><td>10.98</td><td>6.99</td><td>4.56</td><td></td><td>20.88</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>=</td><td></td><td>18.61</td><td>1</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=200)</td><td>13.55</td><td>8.63</td><td></td><td>3.54</td><td>20.67</td><td>18.11</td><td></td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=240)</td><td>19.51</td><td>12.41</td><td></td><td>3.40</td><td>20.58</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+According to the theoretical results, an RK method with more stages usually has a higher order and a lower truncation error. Therefore, as the number of stages increases, a more precise approximation of the system states in every period leads to more accurate classification. Table 1 shows the number of FLOPs and parameters and classification error on CIFAR-10 for RKNets with varying number of stages in each period. The empirical results are consistent with the theoretical properties.
+
+Table 3: Classification errors on ImageNet validation set with a single-crop $( 2 2 4 \times 2 2 4 )$ ). The growth rate $k$ is 32 and $m k$ is the initial number of channels in each period in RKNets. $m _ { n }$ stands for $m$ in the $n$ th period. For each RKNet in this table, $m _ { 0 }$ is 2, $m _ { 1 }$ is 4 and $m _ { 2 }$ is 8. B represents bottleneck. The bottleneck layers which output $4 k$ channels to the following layers are used in ERKNets.   
+
+<table><tr><td>Model</td><td>m3</td><td>FLOPs (G)</td><td>Params (M)</td><td>Top1 (%)</td><td>Top5 (%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ERKNet-3×1_3×1_3×1_1×1-B</td><td>16</td><td>5.20</td><td>6.95</td><td>25.47</td><td>7.81</td></tr><tr><td>ERKNet-3×1_3×1_4×1_2×1-B</td><td>20</td><td>6.35</td><td>14.49</td><td>24.12</td><td>7.17</td></tr><tr><td>ERKNet-3×1_3×1_6×1_2×1-B</td><td>28</td><td>8.50</td><td>25.51</td><td>23.14</td><td>6.66</td></tr></table>
+
+![](images/f788b26a46f073120e78b1ff01754f04850c1b09b7f84227eee08acb24d92866.jpg)  
+Figure 4: Comparison of the DenseNets, CliqueNets and RKNets. The top-1 error rates (single-crop testing) on the ImageNet validation dataset are shown as a function of learned parameters (left) and FLOPs during test-time (right). RKNets compared here are the models shown in Table 3.
+
+IRKNets are evaluated on CIFAR-10, CIFAR-100 and SVHN while ERKNets are evaluated on ImageNet to compare with the state-of-the-art network models. The test errors of IRKNets on CIFAR10, CIFAR-100 and SVHN are shown in Table 2. The top-1 and top-5 errors on ImageNet validation set with a single-crop $( 2 2 4 \times 2 2 4 )$ are shown in Table 3. Figure 4 shows the single-crop top-1 validation errors of DenseNets, CliqueNets and RKNets as a function of the number of parameters (left) and FLOPs (right). According to the experimental results, RKNets are more efficient than the state-of-the-art models on CIFAR-10 and on par on CIFAR-100, SVHN and ImageNet.
+
+# 5 CONCLUSION
+
+We propose to employ a type of numerical ODE methods, the RK methods, to construct convolutional neural networks for image classification tasks. The proposed network architecture can systematically generalize to high order. At the same time, we give a theoretical interpretation of the DenseNet and CliqueNet via the dynamical systems view. The model constructed using the RK methods is referred to as the RKNet, which can be converted from a DenseNet or CliqueNet by enforcing theoretical constraints.
+
+The experimental results validate the theoretical properties of RK methods and support the dynamical systems interpretation. Moreover, the experimental results demonstrate that RKNets surpass the state-of-the-art models on CIFAR-10 and are on par on CIFAR-100, SVHN and ImageNet.
+
+With the help of the dynamical systems view and various numerical ODE methods including RK methods, more general neural networks can be constructed. Many aspects of RKNets and the dynamical systems view still require further investigation. We hope this work inspires future research directions.
+
+# REFERENCES
+
+John Charles Butcher. Numerical methods for ordinary differential equations. John Wiley & Sons, 2008.
+
+Bo Chang, Lili Meng, Eldad Haber, Lars Ruthotto, David Begert, and Elliot Holtham. Reversible architectures for arbitrarily deep residual neural networks. In AAAI Conference on Artificial Intelligence, 2018a.
+
+Bo Chang, Lili Meng, Eldad Haber, Frederick Tung, and David Begert. Multi-level residual networks from dynamical systems view. In International Conference on Learning Representations, 2018b.
+
+Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. In Advances in Neural Information Processing Systems, 2018.
+
+Weinan E. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, Mar 2017. ISSN 2194-671X. doi: 10.1007/s40304-017-0103-z. URL https://doi.org/10.1007/s40304-017-0103-z.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+Eldad Haber, Lars Ruthotto, Elliot Holtham, and Seong-Hwan Jun. Learning across scales - multiscale methods for convolution neural networks. arXiv preprint arXiv:1703.02009, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In The IEEE International Conference on Computer Vision (ICCV), December 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b.
+
+Andrew G Howard. Some improvements on deep convolutional neural network based image classification. In International Conference on Learning Representations, 2014.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Jason Kuen, Xiangfei Kong, Gang Wang, and Yap-Peng Tan. Delugenets: Deep networks with efficient and flexible cross-layer information inflows. In The IEEE International Conference on Computer Vision (ICCV) Workshops, Oct 2017.
+
+Qianxiao Li, Long Chen, Cheng Tai, and Weinan E. Maximum principle based algorithms for deep learning. Journal of Machine Learning Research, 18(165):1–29, 2018. URL http://jmlr. org/papers/v18/17-653.html.
+
+Qianli Liao and Tomaso Poggio. Bridging the gaps between residual learning, recurrent neural networks and visual cortex. arXiv preprint arXiv:1604.03640, 2016.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Zichao Long, Yiping Lu, Xianzhong Ma, and Bin Dong. PDE-net: Learning PDEs from data. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3208–3216, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings. mlr.press/v80/long18a.html.
+
+Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3276–3285, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/v80/ lu18d.html.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf.
+
+Maziar Raissi. Deep hidden physics models: Deep learning of nonlinear partial differential equations. arXiv preprint arXiv:1801.06637, 2018.
+
+Maziar Raissi, Paris Perdikaris, and George Em Karniadakis. Physics informed deep learning (part i): Data-driven solutions of nonlinear partial differential equations. arXiv preprint arXiv:1711.10561, 2017a.
+
+Maziar Raissi, Paris Perdikaris, and George Em Karniadakis. Physics informed deep learning (part ii): Data-driven discovery of nonlinear partial differential equations. arXiv preprint arXiv:1711.10566, 2017b.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations, 2015.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Endre Sli and David F. Mayers. An Introduction to Numerical Analysis. Cambridge University Press, 2003.
+
+Bao Wang, Xiyang Luo, Zhen Li, Wei Zhu, Zuoqiang Shi, and Stanley J Osher. Deep learning with data dependent implicit activation function. arXiv preprint arXiv:1802.00168, 2018.
+
+Yi-Jen Wang and Chin-Teng Lin. Runge-kutta neural network for identification of dynamical systems in high accuracy. IEEE Transactions on Neural Networks, 9(2):294–307, 1998.
+
+Yibo Yang, Zhisheng Zhong, Tiancheng Shen, and Zhouchen Lin. Convolutional neural networks with alternately updated clique. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.
+
+# A EXPERIMENTAL SETUP
+
+The RKNets are evaluated on CIFAR-10, CIFAR-100, SVHN and ImageNet. The CIFAR-10 dataset contains 60,000 color images of size $3 2 \times 3 2$ in 10 classes, with 5,000 training images and 1,000 test images per class. The CIFAR-100 is similar to the CIFAR-10 except that it has 100 classes and 500 training images and 100 test images per class. The Street View House Numbers (SVHN) dataset (Netzer et al., 2011) contains $3 2 \times 3 2$ colored digit images. There are 73,257 images in the training set, 26,032 images in the test set, and 531,131 images for additional training. ImageNet, which denotes the ILSVRC2012 classification dataset in this paper, consists of 1.28 million training images and 50,000 validation images. It has 1,000 classes and $7 3 2 \sim 1 , 3 0 0$ training images and 50 validation images per class.
+
+The weights of convolution layer are initialized as in (He et al., 2015). A weight decay of 0.0001 and Nesterov momentum of 0.9 are used. The learning rate is set to 0.1 initially.
+
+On both CIFAR and SVHN, the learning rate is divided by 10 at $50 \%$ and $7 5 \%$ of the training procedure. Moreover, the weights of fully connected layer are using Xavier initialization (Glorot & Bengio, 2010). For the cases without data augmentation, we add a dropout layer (Srivastava et al., 2014) with dropout rate 0.2 after each convolution layer following (Huang et al., 2017; Yang et al., 2018).
+
+On CIFAR, the models are trained using stochastic gradient descent with a mini-batch size of 64 or 32 as required. A standard data augmentation scheme is adopted in some cases following (He et al., 2016a). The models are trained for 300 epochs.
+
+On SVHN, the models are trained using stochastic gradient descent with a mini-batch size of 64. Following (Yang et al., 2018), we use all training samples without augmentation and divide images by 255 for normalization. The models are trained for 40 epochs.
+
+On ImageNet, the models are trained with a mini-batch size of 256 for 90 epochs. Scale and aspect ratio augmentation in (Szegedy et al., 2015), the standard color augmentation in (Krizhevsky et al., 2012) as well as the photometric distortions in (Howard, 2014) are adopted. The learning rate is divided by 10 every 30 epochs.
+
+# B EXTRA TECHNIQUES
+
+The attentional transition is a channelwise attention mechanism in transition layers, following the method proposed in (Yang et al., 2018). In attentional transition, the filters are globally averaged after the convolution in transition firstly. Then, two fully connected (FC) operations are conducted. The first FC layer has half of the filters and is activated by a ReLU function. The second FC layer has the same number of filters and is activated by a sigmoid function. At last, the output of the second FC layer acts on the output of the convolution by filter-wise multiplication. The bottleneck layer is a $1 \times 1$ convolution layer which is placed before each $3 \times 3$ convolution layer in periods. The multiscale feature strategy is a mechanism in the postprocessor to collect outputs from all the periods but not only from the last period.

parse/train/HJNJws0cF7/HJNJws0cF7_content_list.json

@@ -0,0 +1,1514 @@
+[
+    {
+        "type": "text",
+        "text": "CONVOLUTIONAL NEURAL NETWORKS COMBINED WITH RUNGE-KUTTA METHODS ",
+        "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,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A convolutional neural network for image classification can be constructed mathematically since it can be regarded as a multi-period dynamical system. In this paper, a novel approach is proposed to construct network models from the dynamical systems view. Since a pre-activation residual network can be deemed an approximation of a time-dependent dynamical system using the forward Euler method, higher order Runge-Kutta methods (RK methods) can be utilized to build network models in order to achieve higher accuracy. The model constructed in such a way is referred to as the Runge-Kutta Convolutional Neural Network (RKNet). RK methods also provide an interpretation of Dense Convolutional Networks (DenseNets) and Convolutional Neural Networks with Alternately Updated Clique (CliqueNets) from the dynamical systems view. The proposed methods are evaluated on benchmark datasets: CIFAR-10/100, SVHN and ImageNet. The experimental results are consistent with the theoretical properties of RK methods and support the dynamical systems interpretation. Moreover, the experimental results show that the RKNets are superior to the state-of-the-art network models on CIFAR-10 and on par on CIFAR-100, SVHN and ImageNet. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            334,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Residual Networks (ResNets) which are feed-forward network models with skip connections have achieved great success on several vision benchmarks (He et al., 2016a). Recently, researchers have studied the relation between ResNets and dynamical systems (Liao & Poggio, 2016; E, 2017; Haber et al., 2017; Chang et al., 2018a;b; Lu et al., 2018). Forward Euler method, a first-order RK method, has been employed to explain ResNets with full pre-activation (He et al., 2016b) from the dynamical systems view (Haber et al., 2017; Chang et al., 2018b). Nevertheless, there is no firm evidence to prove that the residual block is just forward Euler method but not any other RK method. We regard the residual mapping as an approximation to the increment in a time-step. The accuracy of the approximation is determined by the structure of the convolutional network. Wide residual network (WRN) (Zagoruyko & Komodakis, 2016) has been proposed to improve the ability of the convolutional subnetwork. However, it is not very efficient only to widen the subnetwork. The new explanation of pre-activation ResNet and its variants which focus on improving residual mapping is one of our contributions. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In addition, some improvements on network architecture based on ordinary differential equations (ODEs) are proposed (Chang et al., 2018a; Lu et al., 2018; Chen et al., 2018). Under the assumption that pre-activation ResNet is forward Euler method, Chang et al. (2018a); Lu et al. (2018) use special linear multi-step methods (LM methods) with low order to construct the network. Chen et al. (2018) utilize a third-party package which offers numerical ODE methods to replace residual block. There is no efficient network architecture for systematic generalization to high order till now. Nevertheless, a higher-order method can achieve a lower truncation error. Since a lower truncation error likely leads to a high accuracy, it is necessary to study an efficient network architecture with a high order. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "If the process of image classification is deemed a sequence of time-dependent dynamical systems, there should be a series of ODEs to describe these systems. RK methods are widely-used procedures to solve ODEs in numerical analysis (Butcher, 2008). They are also the building blocks of highorder LM methods. Consequently, these methods can be used to build network models for visual processing. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The neural network community has long been aware of the numerical methods for dynamical systems. Runge-Kutta Neural Network (RKNN) is proposed for identification of unknown dynamical systems in high accuracy (Wang & Lin, 1998), but it has not been used to model the visual system nor been extended to convolutional networks. Moreover, RKNNs adopt a specific RK methods by indicating every coefficient for the RK methods. Thus, it is hard to apply high order RK methods in RKNNs. In addition, the time-step size need to be prespecified. Hence, RKNN cannot be used in tasks where the total time is unknown such as image classification. In contrast, we learn all the coefficients and time-step sizes implicitly by training in order to avoid these difficulties. As a result, one of the major contributions of the paper is a novel and effective neural network architecture inspired by the RK methods. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to apply RK methods to the image classification problem, the following assumptions are made throughout the paper. Firstly, the image classification procedure is multi-period and there are transitions between adjacent periods. Secondly, each period is modeled by a time-dependent firstorder dynamical system. Based on these assumptions, a novel network model called the RKNet is proposed. ",
+        "bbox": [
+            174,
+            250,
+            823,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In an RKNet, a period is composed of iterations of time-steps. A particular RK method is adopted throughout the time-steps in a period to approximate the increment in each step. The increment in each step is broken down to the increments in several stages according to the adopted RK method. Each stage is approximated by a convolutional subnetwork due to the versatility of neural networks on approximation. ",
+        "bbox": [
+            174,
+            325,
+            823,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another contribution of this paper is a theoretical interpretation of DenseNets and CliqueNets from the dynamical systems view. The dense connections in DenseNet resemble the relationship among increments in the stages in explicit RK methods (ERK methods). Similarly, the clique blocks in CliqueNets resemble the relationship among increments in the stages in implicit RK methods (IRK methods). Under some conditions, DenseNets and CliqueNets can be formulated as approximating dynamical systems using multi-stage RK methods. We also propose a method to convert a DenseNet to an explicit RKNet (ERKNet) and a method convert a CliqueNet to an implicit RKNet (IRKNet). Furthermore, DenseNets and CliqueNets have only one time-step in each period, whereas RKNets are more general and can have multiple time-steps in each period. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of RKNets on benchmark datasets including CIFAR-10, CIFAR100 (Krizhevsky, 2009), SVHN (Netzer et al., 2011) and ILSVRC2012 classification dataset (Russakovsky et al., 2015). Experimental results show that both ERKNets and IRKNets conform to the mathematical properties. Additionally, RKNets achieve higher accuracy than the state-of-the-art network models on CIFAR-10 and comparable accuracy on CIFAR-100, SVHN and ImageNet. ",
+        "bbox": [
+            176,
+            535,
+            823,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. The related work is reviewed in Section 2. The architecture of RKNets, the dynamical systems interpretation of DenseNets and CliqueNets, and the conversion from them to RKNets are described in Section 3. The performance of RKNets is evaluated in Section 4. The conclusion and future work is described in Section 5. ",
+        "bbox": [
+            176,
+            612,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            689,
+            341,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ResNets have gained much attention over the past few years since they have obtained impressive performance on many challenging image tasks, such as ImageNet (Russakovsky et al., 2015) and COCO object detection (Lin et al., 2014). ResNets are deep feed-forward networks with the shortcuts as identity mappings. ResNets with pre-activation can be regarded as an unfolded shallow RNN, which implements a discrete dynamical system (Liao & Poggio, 2016). It provides a novel point of view for explaining pre-activation ResNets from dynamical systems view. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, more work has emerged to connect dynamical systems with deep neural networks (E, 2017) or ResNets in particular (Haber et al., 2017; Chang et al., 2018a;b; Li et al., 2018; Long et al., 2018; Lu et al., 2018; Wang et al., 2018; Chen et al., 2018). E (2017) proposes to use continuous dynamical systems as a tool for machine learning. Chang et al. (2018a) propose three reversible architectures based on ResNets and ODE systems. Chang et al. (2018b) propose a novel method for accelerating ResNets training based on the interpretation of ResNets from dynamical systems view (Haber et al., 2017). Li et al. (2018) present a training algorithm which can be used in the context of ResNets. Lu et al. (2018) propose a 2-step architecture based on ResNets. In addition, research combining dynamical system identification and RK methods with neural networks for scientific computing has emerged recently (Raissi et al., 2017a;b; Raissi, 2018), introducing physics informed neural networks with automatic differentiation. Chen et al. (2018) utilize a third-party package which offers some numerical methods to compute the numerical solution in each time-step. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DenseNets (Huang et al., 2017) are the state-of-the-art network models after ResNets. The dense connection is the main difference from the previous models. There are direct connections from a layer to all subsequent layers in a dense block in order to allow better information and gradient flow. There is no interpretation of DenseNets from dynamical systems view yet. CliqueNets (Yang et al., 2018) are the state-of-the-art network models based on DenseNets. They adopt the alternately updated clique blocks to incorporate both forward and backward connections between any two layers in the same block. However, there is no interpretation of CliqueNets from dynamical systems view yet. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given that the process of image classification is regarded as a sequence of time-dependent dynamical systems, there should be a set of ODEs that describes these systems. Consequently, mathematical tools could be employed to construct network models. RK methods are commonly used to solve ODEs in numerical analysis (Butcher, 2008). Higher order RK methods can achieve lower truncation error. Moreover, these methods are usually the building blocks of high-order LM methods. Therefore, RK methods are ideal tools to construct network models from dynamical systems view. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RK methods have been adopted to construct neural networks, which are known as RKNN, for identification of unknown dynamical systems described by ODEs (Wang & Lin, 1998). In that paper, neural networks are classified into two categories: (1) a network that directly learns the state trajectory of a dynamical system is called a direct-mapping neural network (DMNN); (2) a network that learns the rate of change of system states is called a RKNN. Hence, AlexNet (Krizhevsky et al., 2012), VGGNet (Simonyan & Zisserman, 2015), GoogLeNet (Szegedy et al., 2015) and ResNet (He et al., 2016a) all belong to DMNNs. Specifically, the original ResNet (He et al., 2016a) is a DMNN because of the ReLU layer after the addition operation. As a result, the ResNet building block learns the state trajectory directly, not the rate of change of the system states. On the contrary, a ResNet with pre-activation (He et al., 2016b) is an RKNN. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RKNNs are proposed to eliminate several drawbacks of DMNNs, such as the difficulty in obtaining high accuracy for the multi-step prediction of state trajectories. It has been shown theoretically and experimentally that the RKNN has higher prediction accuracy and better generalization capability than the conventional DMNN (Wang & Lin, 1998). ",
+        "bbox": [
+            174,
+            521,
+            823,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, it is reasonable to believe that RK methods can be adopted to design effective network architectures for image classification problems. Additionally, the RK methods might improve the performance of image classification since the convolutional subnetworks are able to approximate the rate of change of the dynamical system states more precisely. ",
+        "bbox": [
+            176,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RKNETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            281,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The introduction to RK methods are in Section 3.1. We describe the overall structure of RKNet in Section 3.2. The structure of subnetwork for increment in each time-step is elaborated on in Section 3.3. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 RUNGE-KUTTA METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            753,
+            393,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An initial value problem for a time-dependent first-order dynamical system can be described by the following ODE (Butcher, 2008): ",
+        "bbox": [
+            173,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba67db9db2b36416a272661aabfd57d9e81269968506fe9145f8d6ba32d6cfd4.jpg",
+        "text": "$$\n{ \\frac { d { \\pmb y } } { d t } } = f \\left( t , \\pmb y ( t ) \\right) , \\qquad \\pmb y \\left( t _ { 0 } \\right) = \\pmb y _ { 0 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            816,
+            620,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf {  { y } }$ is a vector representing the system state. The dimension of $\\textbf {  { y } }$ should be equal to the dimension of the dynamical system. The ODE represents the rate of change of the system states. The rate of change is a function of time and the current system state. RK methods utilize the rate of change calculated from the ODE to approximate the increment in each time-step, and then obtain the predicted final state at the end of each step. RK methods are numerical methods originated from ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e71843579b62c9107ba64a9e8e4f3b1c926584345b9727647f70fab120e78f4.jpg",
+        "image_caption": [
+            "Figure 1: Architecture of a 3-period RKNet. $\\pmb { y } ^ { ( d ) }$ denotes the system state of period $d$ . $\\pmb { y } _ { 0 } ^ { ( d ) }$ is the initial state of period $d$ . ${ \\pmb y } _ { r } ^ { ( d ) }$ is the final state after $r$ time-steps in period $d , r$ is the total number of time-steps in a period. It can vary in different periods. Period 1 and time-step 1 in it are unfolded as an example. System state changes throughout a period. The final state of a step is estimated as the initial state of this step adding an increment. This operation originates from RK methods. To approximate the increment is the key point in RKNet. The dotted lines are for multiscale feature strategy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            820,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Euler method. There are two types of RK methods: explicit and implicit. Both of them are employed in the RKNet. The family of RK methods is given by the following equations (Sli & Mayers, 2003): ",
+        "bbox": [
+            173,
+            515,
+            821,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9cc9a4b76d7a111a99304845da7776e27a2ce4131c33abdb8ed595ed4142a84a.jpg",
+        "text": "$$\n{ \\pmb y } _ { n + 1 } = { \\pmb y } _ { n } + h \\sum _ { i = 1 } ^ { s } b _ { i } { \\pmb z } _ { i } , \\qquad t _ { n + 1 } = t _ { n } + h ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            547,
+            650,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            173,
+            593,
+            217,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/349f84689fb6867a79a0da82f8b54efd04d2f02fde96aa2e7382cc9afa3ef0ad.jpg",
+        "text": "$$\nz _ { i } = f \\left( t _ { n } + c _ { i } h , \\ y _ { n } + h \\sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \\right) , \\qquad 1 \\leq i \\leq s .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            602,
+            686,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In equation 2, ${ \\mathbf { } } ^ { \\pmb { y } _ { n + 1 } }$ is an approximation of the solution to equation 1 at time $t _ { n + 1 }$ , i.e. $\\boldsymbol { y } ( t _ { n + 1 } )$ ; $\\scriptstyle { \\mathbf { 3 0 } }$ is the input initial value; $\\begin{array} { r } { h \\sum _ { i = 1 } ^ { \\bar { s } } b _ { i } z _ { i } } \\end{array}$ is the increment of system state $\\textbf {  { y } }$ from $t _ { n }$ to $t _ { n + 1 }$ ; $\\textstyle \\sum _ { i = 1 } ^ { s } b _ { i } z _ { i }$ is the estimated slope which is the weighted average of the slopes $z _ { i }$ computed in different stages. The positive integer $s$ is the number of $z _ { i }$ , i.e. the number of stages of the RK method. The equation 3 is the general formula of $z _ { i }$ . $h$ is the time-step size which can be adaptive for different time-steps but must be fixed across stages within a time-step. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In numerical analysis, $s$ , $a _ { i j }$ , $b _ { i }$ and $c _ { i }$ in equation 2 and equation 3 need to be prespecified for a particular RK method. These coefficients are displayed in a Butcher tableau. The ERK methods are those methods with $a _ { i j } = 0$ when $1 \\leq i \\leq j \\leq s$ . All the RK methods other than ERK methods are IRK methods. The algebraic relationships of the coefficients have to meet the order conditions to reach the highest possible order. Different RK methods have different truncation errors which are denoted by the order: an order $p$ indicates that the local truncation error is $O ( h ^ { p + 1 } )$ . If a $s$ -stage ERK method has order $p$ , then $s \\geq p$ ; if $p \\geq 5$ , then $s > p$ (Butcher, 2008). Furthermore, a $s$ -stage IRK method can has order $p = 2 s$ when its coefficients are chosen under some conditions (Butcher, 2008). Therefore, more stages may achieve higher orders, i.e. lower truncation errors. The Euler method is a one-stage first-order RK method with $b _ { 1 } = 1$ and $c _ { 1 } = 0$ . In other words, high-order RK methods can be expected to achieve lower truncation errors than Euler method. Thus, the goal of our proposed RKNets is to improve the classification accuracy by taking advantage of high-order RK methods. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is necessary to specify $h$ in order to control the error of approximation in common numerical analysis. The varying time-step size can be adaptive to the regions with different rates of change. The truncation error is lower when the $h$ is smaller. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 FROM RK METHODS TO RKNETS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            165,
+            446,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are three components of RKNets: the preprocessor, the multi-periods and the postprocessor. The preprocessor manipulates the raw images and passes the results to the first period. The postprocessor deals with the output from the last period or all the periods while adopting multiscale feature strategy (Yang et al., 2018). Then, it passes the result to the classifier to make a decision. The periods between those two components are divided by the transition layers. These periods can be modeled by time-dependent dynamical systems. Each period of an RKNet is divided into $r$ timesteps as shown in Figure 1. RK methods approximate the final state of every time-step using the rate of change of the system state. Some guiding principles when applying RK methods to RKNets are listed as follows. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            318
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Firstly, dimensionality reduction is often carried out to simplify the system identification issue, when the dimension of real dynamical system is too high. The dimension of $\\textbf {  { y } }$ in each period in RKNet is predefined as the multiplication of the size of feature map and the number of channels at the beginning of a period. The dimensions of $\\textbf {  { y } }$ in the same periods of different RKNets can be different due to various degrees of dimensionality reduction. Nevertheless, the dimension of $\\textbf {  { y } }$ is consistent within a period. ",
+        "bbox": [
+            174,
+            325,
+            823,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Secondly, given that there is no explicit ODE for image classification, a convolutional subnetwork is employed to approximate the increment in each time-step. The number of neurons in each hidden layer can be more than the dimension of $\\textbf {  { y } }$ . ",
+        "bbox": [
+            178,
+            415,
+            821,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thirdly, the number of stages $s$ in each period is predefined in RKNet but the other coefficients, $a _ { i j }$ $b _ { i }$ and $c _ { i }$ in equation 2 and equation 3 are learned by training. Due to the order conditions (Butcher, 2008), the relationship among the coefficients are more important than the specific value of any individual coefficient. Hence, the coefficients are learned implicitly but not as explicit parameters. The optimal relationship among the coefficients with a highest possible order is obtained after training. ",
+        "bbox": [
+            174,
+            465,
+            823,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lastly, the number of time-steps $r$ in each period is predefined in RKNet, but the step size $h$ is learned by training. $n$ in equation 2 and equation 3 is limited to the range $[ 0 , r )$ . The learned $h$ is thus considered adaptive. In theory, the adaptive time-step size can achieve higher accuracy. ",
+        "bbox": [
+            176,
+            541,
+            821,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A variety of RK methods can be adopted in the different periods of RKNets, but the same RK method is used for all time-steps within one period in an RKNet. The network models are named after the specific method in each period, such as RKNet- $3 \\times 2 . 4 \\times 1 . 2 \\times 5 . 1 \\times 1$ . The suffix in the name of an RKNet is composed of several $s \\times r$ terms; each stands for the method in corresponding period. The number of such terms equals the total number of periods. $s$ or $r$ can vary in different periods. For example, RKNet- $\\cdot 3 { \\times } 2 . 4 { \\times } 1 . 2 { \\times } 5 . 1 { \\times } 1$ has four periods: period one has 2 time-steps and each step has 3 stages; period two has 1 time-step and it has 4 stages; period three has 5 time-steps and each step has 2 stages; period four has 1 time-step and it has 1 stage. We use this notation throughout this paper. In addition, ERKNets only adopt ERK methods and IRKNets only adopt IRK methods. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given an RKNet model, $s$ and $r$ can be modified to construct more variants with the same dimensions in the corresponding periods. In other words, $s$ and $r$ control depth of the network while dimensionality reduction controls the width of the network. More stages, more time-steps and larger dimensions usually lead to higher classification accuracy. However, the complexity of an ODE increases with the increase of dimensions. As a result, the convolutional subnetwork which approximates the increment in a time-step need be more complex for larger dimensions. Hence, the accuracy is also associated with the matching degree of the dimension and the convolutional subnetwork. The unmatched high-dimensional network model may have lower accuracy. Additionally, the training method might affect the classification accuracy too. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ERKNETS AND IRKNETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            867,
+            395,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the architecture of RKNets. As shown in equation 2, the sum of $h b _ { i } z _ { i }$ represents the increment in a time-step. It is crucial to approximate this increment in RKNet. For ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/289c04b98656e522707995f6f43d5d3bb5e2b591c63fc7eb12570933a0a3de3f.jpg",
+        "image_caption": [
+            "Figure 2: Architecture of one time-step in ERKNet using an $s$ -stage ERK method. ${ \\bf { { y } } } _ { n }$ is the approximation of $\\pmb { y } ( t _ { n } )$ . A dense block grows every $m$ times at a growth rate of $k$ to form a convolutional subnetwork for generating each $h b _ { i } z _ { i }$ . Here, $h$ is time-step size, $b _ { i }$ is coefficient of ERK method, and $z _ { i }$ is the slope of each stage in ERK method. The total number of growth is $m s$ in a dense block in order to generate $h b _ { i } z _ { i }$ for $i = 1$ , . . . , $s$ . An explicit summation layer is added after a dense block to complete a time-step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            101,
+            823,
+            316
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "the purpose of constructing an RKNet, it is necessary to hide the time-step size and the coefficients in RK methods. $h b _ { i } z _ { i }$ can be described as follows according to equation 3: ",
+        "bbox": [
+            173,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/141bba20b815c67c50892724932684dfd18115c5eacd9032fdf09597a0483ab6.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle h b _ { i } z _ { i } = h b _ { i } f \\left( t _ { n } + c _ { i } h , ~ y _ { n } + h \\sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \\right) } } \\\\ { { \\displaystyle ~ = g _ { i } \\left( y _ { n } + h \\sum _ { j = 1 } ^ { s } a _ { i j } z _ { j } \\right) } } \\\\ { { \\displaystyle ~ = F _ { i } \\left( y _ { n } , ~ h a _ { i 1 } z _ { 1 } , ~ . . . , ~ h a _ { i s } z _ { s } \\right) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            477,
+            651,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The above transformation first changes the explicit dependence on the time in equation 3 to an implicit one. Since the time parameter $t _ { n } + c _ { i } h$ is different for the different stages, it can be absorbed into $g _ { i } ( \\cdot )$ , which implicitly depends on time for stage $i$ . Afterward, the summation in the input parameter of $g _ { i } ( \\cdot )$ is split into separate terms. $F _ { i } ( \\cdot )$ denotes the function of these terms for each stage. We verify that $F _ { i } ( \\cdot )$ can equal to $g _ { i } ( \\cdot )$ after training by experiment though $F _ { i } ( \\cdot )$ is more expressive than $g _ { i } ( \\cdot )$ in expression. Additionally, $F _ { i } ( \\cdot )$ is more memory efficient than $g _ { i } ( \\cdot )$ because of saving the storage for the summation inputted to $g _ { i } ( \\cdot )$ . ",
+        "bbox": [
+            173,
+            597,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 CONNECT ERKNETS WITH DENSENETS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            709,
+            509,
+            724
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to construct ERKNets, $h b _ { i } z _ { i }$ can be described by the equation below, according to equation 4. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/012b89463c075060aac2b51394d6d251b3de208a8c018817f2d0246311a2767c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { h b _ { i } z _ { i } = e _ { i } \\left( { { y } _ { n } } , \\ h a _ { i 1 } { { z } _ { 1 } } , \\ \\ldots , \\ h a _ { i ( i - 1 ) } { { z } _ { i - 1 } } \\right) } \\\\ & { \\qquad = E _ { i } \\left( { { y } _ { n } } , \\ h b _ { 1 } { { z } _ { 1 } } , \\ \\ldots , \\ h b _ { i - 1 } { { z } _ { i - 1 } } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            762,
+            647,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The above transformation first eliminates $h a _ { i j } z _ { j }$ $( i \\leq j )$ from $F _ { i } ( \\cdot )$ in equation 4 since $a _ { i j } = 0$ when $1 \\leq i \\leq j \\leq s$ for ERK methods (See 3.1). As a result, $h b _ { i } z _ { i }$ is denoted by a function of $y _ { n }$ and $h a _ { i j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ . It is written as $e _ { i } ( \\cdot )$ . After that, adjusting the coefficients of each parameter from $a _ { i j }$ to $b _ { j }$ yields another function $E _ { i } ( \\cdot )$ . It is a function of $y _ { n }$ and $h b _ { j } z _ { j }$ for $j = 1 , \\ldots , i - 1$ . ",
+        "bbox": [
+            173,
+            804,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If a convolutional subnetwork is adopted to model $E _ { i } ( \\cdot )$ in equation 5, the most similar network structure is the dense connections in DenseNets. To be specific, a growth in a dense block concatenates all the preceding layers as the input of convolutional subnetwork just like that $h b _ { i } z _ { i }$ uses $y _ { n }$ and all the increments in preceding stages as the input of $E _ { i } ( \\cdot )$ . For the purpose of adopting dense block in ERKNets, the dense blocks must conform to the following rules. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Rule 1 The number of channels of ${ \\bf { { y } } } _ { n }$ is in the form of $m k$ , where $m$ and $k$ are positive integers and $k$ is known as the growth rate in DenseNet literature. The dimension of ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ is the multiplication of the size of feature map and $m k$ . ",
+        "bbox": [
+            174,
+            138,
+            823,
+            181
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Rule 2 Every $m$ successive growth constructs a convolutional subnetwork for $E _ { i } ( \\cdot )$ . Each subnetwork outputs mk channels which are regarded as a group according to the number of channels of ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ . Each convolutional subnetwork concatenates ${ \\bf { { y } } } _ { n }$ and all the preceding groups as its input. The $i$ th group generated by the ith subnetwork corresponds to $h b _ { i } z _ { i }$ . ",
+        "bbox": [
+            174,
+            188,
+            825,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Rule 3 The total number of growth is $m s$ , where $s$ is number of stages of RK methods. Consequently, $s$ groups representing $h b _ { i } z _ { i }$ for $i = 1$ , . . . , $s$ are generated by $s$ convolutional subnetworks modeling $E _ { i } ( \\cdot )$ for $i = 1$ , . . . , $s$ successively in a dense block. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Appending to a restricted dense block conforming to the above rules, ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ and the groups $h b _ { i } z _ { i }$ for $i = 1 , \\dots , s$ are added to obtain $\\mathbf { \\nabla } _ { \\mathbf { y } _ { n + 1 } }$ according to equation 2. Figure 2 illustrates one time-step of ERKNet. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In DenseNets, every dense block together with part of the subsequent computation can be regarded as a period using a $s$ -stage ERK method with $r = 1$ time-step. The transition layers and the postprocessor contain the summation operation in equation 2. This gives an explanation of DenseNets from the dynamical systems view. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 CONNECT IRKNETS WITH CLIQUENETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            509,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$h b _ { i } z _ { i }$ for IRK methods can be described by the equation below, according to equation 4. ",
+        "bbox": [
+            173,
+            444,
+            751,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64dfc9bab7029f60ec2070bcf06e26fe28ade8de0eb838c6c8c3f0cbe1f32b28.jpg",
+        "text": "$$\n\\begin{array} { r l } & { h b _ { i } z _ { i } = H _ { i } \\left( y _ { n } , \\ h b _ { 1 } z _ { 1 } , \\ \\ldots , \\ h b _ { s } z _ { s } \\right) } \\\\ & { \\qquad = G _ { i } \\left( h b _ { 1 } z _ { 1 } , \\ \\ldots , \\ h b _ { i - 1 } z _ { i - 1 } , \\ h b _ { i + 1 } z _ { i + 1 } , \\ \\ldots , \\ h b _ { s } z _ { s } \\right) } \\\\ & { \\qquad = I _ { i } \\left( h b _ { 1 } z _ { 1 } , \\ \\ldots , \\ h b _ { i - 1 } z _ { i - 1 } , \\ v _ { i + 1 } , \\ \\ldots , \\ v _ { s } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            463,
+            705,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            173,
+            523,
+            217,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ba37aeb73a2a8e7536ba5e4ec5565171548f9270ebe1ad91e8129d31a341143.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\pmb { v } } _ { j } = V _ { j } ( h b _ { j } z _ { j } ) } \\\\ { = J _ { j } \\left( \\pmb { y } _ { n } , \\ \\pmb { v } _ { 1 } , \\ \\dots , \\ \\pmb { v } _ { j - 1 } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            540,
+            601,
+            578
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The above transformation first adjusts the coefficients of each parameter of $F _ { i } ( \\cdot )$ in equation 4 from $a _ { i j }$ to $b _ { j }$ . It yields another function $H _ { i } ( \\cdot )$ . As a result, every $h b _ { i } z _ { i }$ is a function of $y _ { n }$ . Thus, $h b _ { i } z _ { i }$ can be denoted by a function of $h b _ { j } z _ { j }$ for $j = 1 , \\ \\dots , \\ s , \\ j \\neq i$ . This function is written as $G _ { i } ( \\cdot )$ . ",
+        "bbox": [
+            173,
+            582,
+            823,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Newton method which is used to implement IRK methods (Butcher, 2008), $h b _ { i } z _ { i }$ is initialized using all available information firstly and then updated alternately. Given $v _ { j }$ is the initial value of $h b _ { j } z _ { j }$ , the relationship between them is denoted by the function $V _ { j } ( \\cdot )$ . Therefore, $h b _ { i } z _ { i }$ can be denoted by a function of $h b _ { j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ and ${ \\boldsymbol { v } } _ { j }$ for $j = i \\dot { + } 1$ , . . . , $s$ . This function is written as $I _ { i } ( \\cdot )$ . It is the update function of $h b _ { i } z _ { i }$ . Since every $h b _ { j } z _ { j }$ is a function of $y _ { n }$ , every ${ \\pmb v } _ { j }$ is also a function of $y _ { n }$ . Thus, $v _ { j }$ can be denoted by a function of $y _ { n }$ and $v _ { q }$ for $q = 1$ , . . . , $j - 1$ . This function is written as $J _ { j } ( \\cdot )$ . It is the initialization function of $h b _ { j } z _ { j }$ . ",
+        "bbox": [
+            173,
+            631,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The update process is a sequence of iterations till convergence in Newton method. In other words, ${ \\pmb v } _ { j }$ is updated for many times to approach $h b _ { j } z _ { j }$ . During updating, $G _ { i } ( \\cdot )$ with the biased input is used as the update function since $I _ { i } ( \\cdot )$ is unknown. If using convolutional subnetwork to model each $I _ { i } ( \\cdot )$ , these functions can be learned under the help of training. As a result, each ${ \\boldsymbol { v } } _ { j }$ needs to be updated only once. Therefore, the computational cost is reduced remarkably. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            806
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "If a convolutional subnetwork is adopted to model $J _ { j } ( \\cdot )$ in equation 7 and $I _ { i } ( \\cdot )$ in equation 6, the most similar network structure is the clique block in CliqueNets. To be specific, a clique block is composed of Stage-I and Stage-II in CliqueNet literature. Stage-I which initializes all layers in a clique block is regarded as a sequence of $J _ { j } ( \\cdot )$ . Then, Stage-II for updating all layers alternately corresponds to all $I _ { i } ( \\cdot )$ . In CliqueNet literature, all layers in a clique block except the top layer to be updated are concatenated as the bottom layer, i.e. the input of a convolutional subnetwork for updating. It is just like $I _ { i } ( \\cdot )$ uses $h b _ { j } z _ { j }$ for $j = 1$ , . . . , $i - 1$ and ${ \\pmb v } _ { j }$ for $j = i + 1$ , . . . , $s$ as input. In order to adopt clique block in IRKNets, the clique blocks must conform to the following rules. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3964a1541e8814e122044fe8ad72fd24615d1403b7304702d7acbd86036528a0.jpg",
+        "image_caption": [
+            "Figure 3: Architecture of one time-step in IRKNet using a 3-stage IRK method. ${ \\bf { { y } } } _ { n }$ is the approximation of $\\pmb { y } ( t _ { n } )$ . A dense block, which is Stage-I of a clique block, grows $k$ channels every time to generate the initial value of each $h b _ { i } z _ { i }$ , written as ${ \\mathbf { } } v _ { i }$ . Here, $h$ is time-step size, $b _ { i }$ is coefficient of IRK method, and $z _ { i }$ is the slope of each stage in IRK method. In Stage-II of a clique block, the convolutional subnetwork concatenating the current values of $h b _ { j } z _ { j }$ for $j = 1$ , . . . , 3, $j \\neq i$ to update every $h b _ { i } z _ { i }$ alternately. An explicit summation layer is added after a clique block to complete a time-step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            826,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Rule 1 The number of channels of ${ \\bf { { y } } } _ { n }$ is $k$ , which is the growth rate in Stage-I since Stage-I is a dense block. The dimension of ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ is the multiplication of the size of feature map and $k$ . ",
+        "bbox": [
+            173,
+            531,
+            823,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Rule 2 Every growth in Stage-I constructs a convolutional subnetwork. Each subnetwork outputs $k$ channels which are regarded as a group according to the number of channels of ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ . Each convolutional subnetwork concatenates ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ and all the preceding groups as its input. The ith group generated by the ith subnetwork is ${ \\mathbf { } } v _ { i }$ . ",
+        "bbox": [
+            174,
+            568,
+            825,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Rule 3 The total number of growth in Stage-I is $s$ , which is number of stages of RK methods. Consequently, $s$ groups representing ${ \\mathbf { } } v _ { i }$ for $i = 1$ , . . . , $s$ are generated by $s$ convolutional subnetworks successively in Stage-I. $s$ should be larger than 1 for updating alternately in Stage-II. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Appending to a restricted clique block conforming to the above rules, ${ \\bf { \\nabla } } \\pmb { y } _ { n }$ and the groups $h b _ { i } z _ { i }$ for $i = 1 , \\dots , s$ are added to obtain $\\mathbf { \\nabla } _ { \\mathbf { y } _ { n + 1 } }$ according to equation 2. Figure 3 illustrates one time-step of IRKNet using a 3-stage IRK method as an example. ",
+        "bbox": [
+            174,
+            679,
+            821,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In CliqueNets, every clique block together with part of the subsequent computation can be regarded as a period using a $s$ -stage IRK method with $r = 1$ time-step. The transition layers and the postprocessor contain the summation operation in equation 2. This gives an explanation of CliqueNets from the dynamical systems view. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            326,
+            832
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To verify the theoretical properties of RK methods and evaluate the performance of RKNets on image classification, experiments are conducted using the proposed network architectures. The experimental setup is described in Appendix A. Some extra techniques, including attentional transition, bottleneck and multiscale feature strategy, can be adopted in RKNets following CliqueNets. They are introduced in Appendix B. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f8e9b39d62d31aefe645d82b38fd40363aea240a316260e4e85c13f5fb94ccad.jpg",
+        "table_caption": [
+            "Table 1: Test errors of ERKNets and IRKNets, evaluated on CIFAR-10 without data augmentation. The growth rate $k$ is 36 in every period of the RKNets. The times of successive growth in each stage, $m$ , is 1. The multiscale feature strategy is used. All the models are run with batchsize 64. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ERKNet</td><td>FLOPs (G)</td><td>Params (M)</td><td>Error (%)</td><td>IRKNet</td><td>FLOPs (G)</td><td>Params (M)</td><td>Error (%）</td></tr><tr><td>-6×1_6×1.6×1</td><td></td><td>0.74</td><td>7.08</td><td>-3×1_3×1_3×1</td><td>0.38</td><td>0.32</td><td></td></tr><tr><td>-7×1.6×1.6×1</td><td>0.66 0.83</td><td>0.83</td><td>7.02</td><td>-4×1.3×1.3×1</td><td>0.62</td><td>0.40</td><td>7.18 6.89</td></tr><tr><td>-7×1_7×1_6×1</td><td>0.87</td><td>0.91</td><td>6.67</td><td>-4×1_4×1.3×1</td><td>0.68</td><td>0.49</td><td>6.63</td></tr><tr><td>-7×1_7×1_7×1</td><td>0.88</td><td>0.99</td><td>6.61</td><td>-4×1_4×1_4×1</td><td>0.69</td><td>0.57</td><td>6.50</td></tr></table>",
+        "bbox": [
+            174,
+            159,
+            825,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/65134df8b54aef235effc3ae2685080adb70a744f4c671514f16a448b3ab425a.jpg",
+        "table_caption": [
+            "Table 2: Test errors evaluated on CIFAR and SVHN. $k$ is growth rate. The multiscale feature strategy is used in RKNets. A and B represent attentional transition and bottleneck respectively. The bottleneck layers which output $k$ channels to the following layers are used in IRKNets. C10 and C100 stand for CIFAR-10 and CIFAR-100 respectively. $\\ \" + \\ \"$ indicates standard data augmentation. When data augmentation is not used, dropout layers are added. The values with \\* are provided by Huang et al. (2017). The values with $\\dagger$ are provided by Kuen et al. (2017). The values with $\\star$ are computed by ourselves. FLOPs and Params are calculated on CIFAR-10 or SVHN. RKNets are run with batchsize 32 on CIFAR but run with batchsize 64 on SVHN. Results that outperform all competing methods are bold and the overall best result is blue. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>FLOPs ParamsC10 (G)</td><td>(M)</td><td>(%）</td><td>C10+ (%）</td><td>C100 (%）</td><td>(%）</td><td>C100+ SVHN (%）</td></tr><tr><td>pre-act ResNet (He et al., 2016b)</td><td></td><td>10.2</td><td>10.56*</td><td>4.62</td><td>33.47*</td><td>22.71</td><td></td></tr><tr><td>WRN (Zagoruyko &amp; Komodakis,2016)</td><td>3.10+ 10.49+</td><td>11.0 36.5</td><td></td><td>4.27 4.00</td><td>一 =</td><td>20.43 19.25</td><td>1.54</td></tr><tr><td>DenseNet (Huang et al., 2017)</td><td>14.53* 27.2 10.83* 15.3</td><td></td><td>5.83 5.19</td><td>3.74 3.62</td><td>23.42 19.64</td><td>19.25 17.60</td><td>1.59 1.74</td></tr><tr><td>Hamiltonian (Chang et al.,2018a)</td><td>18.59* 25.6</td><td>1.68</td><td>1</td><td>3.46 5.98</td><td></td><td>17.18</td><td></td></tr><tr><td>LM-architecture (Lu et al., 2018)</td><td></td><td>1.7</td><td></td><td>5.27</td><td>=</td><td>26.11 22.9</td><td></td></tr><tr><td>CliqueNet (Yang et al., 2018)</td><td></td><td>68.8</td><td></td><td>=</td><td>1</td><td>16.79</td><td></td></tr><tr><td></td><td>9.45 10.56*</td><td>10.14 10.48× 5.06</td><td>5.06</td><td></td><td>23.14 21.83</td><td></td><td>1.51 1.64</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=80)</td><td>2.17</td><td>1.40</td><td>5.27</td><td></td><td></td><td></td><td></td></tr><tr><td>IRKNet-5×1_5×1_5×1-A (k=80)</td><td>5.44</td><td></td><td></td><td>4.23</td><td>24.35</td><td>21.77</td><td>1.74</td></tr><tr><td></td><td></td><td>4.37</td><td>■</td><td>=</td><td>1</td><td>=</td><td>1.63</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=150)</td><td>7.62</td><td>4.87</td><td>4.60</td><td>3.60</td><td>21.39</td><td>19.42</td><td>1.64</td></tr><tr><td>IRKNet-6×1_6×1_6×1-A (k=80)</td><td>7.92</td><td>6.28</td><td></td><td></td><td>=</td><td></td><td>1.52</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=180)</td><td>10.98</td><td>6.99</td><td>4.56</td><td></td><td>20.88</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>=</td><td></td><td>18.61</td><td>1</td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=200)</td><td>13.55</td><td>8.63</td><td></td><td>3.54</td><td>20.67</td><td>18.11</td><td></td></tr><tr><td>IRKNet-5×1_5×1_5×1-AB (k=240)</td><td>19.51</td><td>12.41</td><td></td><td>3.40</td><td>20.58</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            431,
+            826,
+            811
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "According to the theoretical results, an RK method with more stages usually has a higher order and a lower truncation error. Therefore, as the number of stages increases, a more precise approximation of the system states in every period leads to more accurate classification. Table 1 shows the number of FLOPs and parameters and classification error on CIFAR-10 for RKNets with varying number of stages in each period. The empirical results are consistent with the theoretical properties. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a51f40c01ee08b9aee6f9f79f5959d929858538b93b548607bce56cb5e3ec14b.jpg",
+        "table_caption": [
+            "Table 3: Classification errors on ImageNet validation set with a single-crop $( 2 2 4 \\times 2 2 4 )$ ). The growth rate $k$ is 32 and $m k$ is the initial number of channels in each period in RKNets. $m _ { n }$ stands for $m$ in the $n$ th period. For each RKNet in this table, $m _ { 0 }$ is 2, $m _ { 1 }$ is 4 and $m _ { 2 }$ is 8. B represents bottleneck. The bottleneck layers which output $4 k$ channels to the following layers are used in ERKNets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>m3</td><td>FLOPs (G)</td><td>Params (M)</td><td>Top1 (%)</td><td>Top5 (%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ERKNet-3×1_3×1_3×1_1×1-B</td><td>16</td><td>5.20</td><td>6.95</td><td>25.47</td><td>7.81</td></tr><tr><td>ERKNet-3×1_3×1_4×1_2×1-B</td><td>20</td><td>6.35</td><td>14.49</td><td>24.12</td><td>7.17</td></tr><tr><td>ERKNet-3×1_3×1_6×1_2×1-B</td><td>28</td><td>8.50</td><td>25.51</td><td>23.14</td><td>6.66</td></tr></table>",
+        "bbox": [
+            174,
+            171,
+            825,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/f788b26a46f073120e78b1ff01754f04850c1b09b7f84227eee08acb24d92866.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of the DenseNets, CliqueNets and RKNets. The top-1 error rates (single-crop testing) on the ImageNet validation dataset are shown as a function of learned parameters (left) and FLOPs during test-time (right). RKNets compared here are the models shown in Table 3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            339,
+            810,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "IRKNets are evaluated on CIFAR-10, CIFAR-100 and SVHN while ERKNets are evaluated on ImageNet to compare with the state-of-the-art network models. The test errors of IRKNets on CIFAR10, CIFAR-100 and SVHN are shown in Table 2. The top-1 and top-5 errors on ImageNet validation set with a single-crop $( 2 2 4 \\times 2 2 4 )$ are shown in Table 3. Figure 4 shows the single-crop top-1 validation errors of DenseNets, CliqueNets and RKNets as a function of the number of parameters (left) and FLOPs (right). According to the experimental results, RKNets are more efficient than the state-of-the-art models on CIFAR-10 and on par on CIFAR-100, SVHN and ImageNet. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            693,
+            318,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose to employ a type of numerical ODE methods, the RK methods, to construct convolutional neural networks for image classification tasks. The proposed network architecture can systematically generalize to high order. At the same time, we give a theoretical interpretation of the DenseNet and CliqueNet via the dynamical systems view. The model constructed using the RK methods is referred to as the RKNet, which can be converted from a DenseNet or CliqueNet by enforcing theoretical constraints. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The experimental results validate the theoretical properties of RK methods and support the dynamical systems interpretation. Moreover, the experimental results demonstrate that RKNets surpass the state-of-the-art models on CIFAR-10 and are on par on CIFAR-100, SVHN and ImageNet. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "With the help of the dynamical systems view and various numerical ODE methods including RK methods, more general neural networks can be constructed. Many aspects of RKNets and the dynamical systems view still require further investigation. We hope this work inspires future research directions. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Charles Butcher. Numerical methods for ordinary differential equations. John Wiley & Sons, 2008. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            154
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Chang, Lili Meng, Eldad Haber, Lars Ruthotto, David Begert, and Elliot Holtham. Reversible architectures for arbitrarily deep residual neural networks. In AAAI Conference on Artificial Intelligence, 2018a. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Chang, Lili Meng, Eldad Haber, Frederick Tung, and David Begert. Multi-level residual networks from dynamical systems view. In International Conference on Learning Representations, 2018b. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            169,
+            263,
+            823,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weinan E. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, Mar 2017. ISSN 2194-671X. doi: 10.1007/s40304-017-0103-z. URL https://doi.org/10.1007/s40304-017-0103-z. ",
+        "bbox": [
+            178,
+            301,
+            821,
+            344
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010. ",
+        "bbox": [
+            176,
+            352,
+            823,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eldad Haber, Lars Ruthotto, Elliot Holtham, and Seong-Hwan Jun. Learning across scales - multiscale methods for convolution neural networks. arXiv preprint arXiv:1703.02009, 2017. ",
+        "bbox": [
+            171,
+            404,
+            821,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In The IEEE International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016a. ",
+        "bbox": [
+            176,
+            491,
+            823,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard. Some improvements on deep convolutional neural network based image classification. In International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            171,
+            579,
+            823,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            176,
+            616,
+            825,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            667,
+            691,
+            683
+        ],
+        "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, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            690,
+            825,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Kuen, Xiangfei Kong, Gang Wang, and Yap-Peng Tan. Delugenets: Deep networks with efficient and flexible cross-layer information inflows. In The IEEE International Conference on Computer Vision (ICCV) Workshops, Oct 2017. ",
+        "bbox": [
+            174,
+            742,
+            823,
+            785
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qianxiao Li, Long Chen, Cheng Tai, and Weinan E. Maximum principle based algorithms for deep learning. Journal of Machine Learning Research, 18(165):1–29, 2018. URL http://jmlr. org/papers/v18/17-653.html. ",
+        "bbox": [
+            173,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qianli Liao and Tomaso Poggio. Bridging the gaps between residual learning, recurrent neural networks and visual cortex. arXiv preprint arXiv:1604.03640, 2016. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zichao Long, Yiping Lu, Xianzhong Ma, and Bin Dong. PDE-net: Learning PDEs from data. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3208–3216, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings. mlr.press/v80/long18a.html. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3276–3285, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/v80/ lu18d.html. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            339
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Maziar Raissi. Deep hidden physics models: Deep learning of nonlinear partial differential equations. arXiv preprint arXiv:1801.06637, 2018. ",
+        "bbox": [
+            169,
+            352,
+            823,
+            380
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Maziar Raissi, Paris Perdikaris, and George Em Karniadakis. Physics informed deep learning (part i): Data-driven solutions of nonlinear partial differential equations. arXiv preprint arXiv:1711.10561, 2017a. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Maziar Raissi, Paris Perdikaris, and George Em Karniadakis. Physics informed deep learning (part ii): Data-driven discovery of nonlinear partial differential equations. arXiv preprint arXiv:1711.10566, 2017b. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            176,
+            502,
+            823,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            558,
+            820,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Endre Sli and David F. Mayers. An Introduction to Numerical Analysis. Cambridge University Press, 2003. ",
+        "bbox": [
+            174,
+            723,
+            823,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bao Wang, Xiyang Luo, Zhen Li, Wei Zhu, Zuoqiang Shi, and Stanley J Osher. Deep learning with data dependent implicit activation function. arXiv preprint arXiv:1802.00168, 2018. ",
+        "bbox": [
+            171,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi-Jen Wang and Chin-Teng Lin. Runge-kutta neural network for identification of dynamical systems in high accuracy. IEEE Transactions on Neural Networks, 9(2):294–307, 1998. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yibo Yang, Zhisheng Zhong, Tiancheng Shen, and Zhouchen Lin. Convolutional neural networks with alternately updated clique. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016. ",
+        "bbox": [
+            174,
+            901,
+            725,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            400,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The RKNets are evaluated on CIFAR-10, CIFAR-100, SVHN and ImageNet. The CIFAR-10 dataset contains 60,000 color images of size $3 2 \\times 3 2$ in 10 classes, with 5,000 training images and 1,000 test images per class. The CIFAR-100 is similar to the CIFAR-10 except that it has 100 classes and 500 training images and 100 test images per class. The Street View House Numbers (SVHN) dataset (Netzer et al., 2011) contains $3 2 \\times 3 2$ colored digit images. There are 73,257 images in the training set, 26,032 images in the test set, and 531,131 images for additional training. ImageNet, which denotes the ILSVRC2012 classification dataset in this paper, consists of 1.28 million training images and 50,000 validation images. It has 1,000 classes and $7 3 2 \\sim 1 , 3 0 0$ training images and 50 validation images per class. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The weights of convolution layer are initialized as in (He et al., 2015). A weight decay of 0.0001 and Nesterov momentum of 0.9 are used. The learning rate is set to 0.1 initially. ",
+        "bbox": [
+            173,
+            265,
+            821,
+            294
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On both CIFAR and SVHN, the learning rate is divided by 10 at $50 \\%$ and $7 5 \\%$ of the training procedure. Moreover, the weights of fully connected layer are using Xavier initialization (Glorot & Bengio, 2010). For the cases without data augmentation, we add a dropout layer (Srivastava et al., 2014) with dropout rate 0.2 after each convolution layer following (Huang et al., 2017; Yang et al., 2018). ",
+        "bbox": [
+            174,
+            300,
+            825,
+            369
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On CIFAR, the models are trained using stochastic gradient descent with a mini-batch size of 64 or 32 as required. A standard data augmentation scheme is adopted in some cases following (He et al., 2016a). The models are trained for 300 epochs. ",
+        "bbox": [
+            176,
+            377,
+            821,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On SVHN, the models are trained using stochastic gradient descent with a mini-batch size of 64. Following (Yang et al., 2018), we use all training samples without augmentation and divide images by 255 for normalization. The models are trained for 40 epochs. ",
+        "bbox": [
+            176,
+            426,
+            821,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, the models are trained with a mini-batch size of 256 for 90 epochs. Scale and aspect ratio augmentation in (Szegedy et al., 2015), the standard color augmentation in (Krizhevsky et al., 2012) as well as the photometric distortions in (Howard, 2014) are adopted. The learning rate is divided by 10 every 30 epochs. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            531
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B EXTRA TECHNIQUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            382,
+            568
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The attentional transition is a channelwise attention mechanism in transition layers, following the method proposed in (Yang et al., 2018). In attentional transition, the filters are globally averaged after the convolution in transition firstly. Then, two fully connected (FC) operations are conducted. The first FC layer has half of the filters and is activated by a ReLU function. The second FC layer has the same number of filters and is activated by a sigmoid function. At last, the output of the second FC layer acts on the output of the convolution by filter-wise multiplication. The bottleneck layer is a $1 \\times 1$ convolution layer which is placed before each $3 \\times 3$ convolution layer in periods. The multiscale feature strategy is a mechanism in the postprocessor to collect outputs from all the periods but not only from the last period. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            709
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HJgcvJBFvB/HJgcvJBFvB.md

@@ -0,0 +1,433 @@
+# NETWORK RANDOMIZATION:A SIMPLE TECHNIQUE FOR GENERALIZATIONIN DEEP REINFORCEMENT LEARNING
+
+Kimin $\mathbf { L e e ^ { \mathrm { 1 * \dagger } } }$ , Kibok $\mathbf { L e e ^ { 2 * } }$ , Jinwoo $\mathbf { S h i n ^ { 1 } }$ , Honglak Lee32 1KAIST, 2University of Michigan, 3Google Brain
+
+# ABSTRACT
+
+Deep reinforcement learning (RL) agents often fail to generalize to unseen environments (yet semantically similar to trained agents), particularly when they are trained on high-dimensional state spaces, such as images. In this paper, we propose a simple technique to improve a generalization ability of deep RL agents by introducing a randomized (convolutional) neural network that randomly perturbs input observations. It enables trained agents to adapt to new domains by learning robust features invariant across varied and randomized environments. Furthermore, we consider an inference method based on the Monte Carlo approximation to reduce the variance induced by this randomization. We demonstrate the superiority of our method across 2D CoinRun, 3D DeepMind Lab exploration and 3D robotics control tasks: it significantly outperforms various regularization and data augmentation methods for the same purpose. Code is available at github.com/pokaxpoka/netrand.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning (RL) has been applied to various applications, including board games (e.g., Go (Silver et al., 2017) and Chess (Silver et al., 2018)), video games (e.g., Atari games (Mnih et al., 2015) and StarCraft (Vinyals et al., 2017)), and complex robotics control tasks (Tobin et al., 2017; Ren et al., 2019). However, it has been evidenced in recent years that deep RL agents often struggle to generalize to new environments, even when semantically similar to trained agents (Farebrother et al., 2018; Zhang et al., 2018b; Gamrian & Goldberg, 2019; Cobbe et al., 2019). For example, RL agents that learned a near-optimal policy for training levels in a video game fail to perform accurately in unseen levels (Cobbe et al., 2019), while a human can seamlessly generalize across similar tasks. Namely, RL agents often overfit to training environments, thus the lack of generalization ability makes them unreliable in several applications, such as health care (Chakraborty & Murphy, 2014) and finance (Deng et al., 2016).
+
+The generalization of RL agents can be characterized by visual changes (Cobbe et al., 2019; Gamrian & Goldberg, 2019), different dynamics (Packer et al., 2018), and various structures (Beattie et al., 2016; Wang et al., 2016). In this paper, we focus on the generalization across tasks where the trained agents take various unseen visual patterns at the test time, e.g., different styles of backgrounds, floors, and other objects (see Figure 1). We also found that RL agents completely fail due to small visual changes1 because it is challenging to learn generalizable representations from high-dimensional input observations, such as images.
+
+To improve generalization, several strategies, such as regularization (Farebrother et al., 2018; Zhang et al., 2018b; Cobbe et al., 2019) and data augmentation (Tobin et al., 2017; Ren et al., 2019), have been proposed in the literature (see Section 2 for further details). In particular, Tobin et al. (2017) showed that training RL agents in various environments generated by randomizing rendering in a simulator improves the generalization performance, leading to a better performance in real environments. This implies that RL agents can learn invariant and robust representations if diverse input observations are provided during training. However, their method is limited by requiring a physics simulator, which may not always be available. This motivates our approach of developing a simple and plausible method applicable to training deep RL agents.
+
+![](images/a53472f4d6ab15eedf177efdd274101abf01bdf619f789859140596df7e100d1.jpg)  
+Figure 1: (a) Examples of randomized inputs (color values in each channel are normalized for visualization) generated by re-initializing the parameters of a random layer. Examples of seen and unseen environments on (b) CoinRun, (c) DeepMind Lab, and (d) Surreal robotics control.
+
+The main contribution of this paper is to develop a simple randomization technique for improving the generalization ability across tasks with various unseen visual patterns. Our main idea is to utilize random (convolutional) networks to generate randomized inputs (see Figure 1(a)), and train RL agents (or their policy) by feeding them into the networks. Specifically, by re-initializing the parameters of random networks at every iteration, the agents are encouraged to be trained under a broad range of perturbed low-level features, e.g., various textures, colors, or shapes. We discover that the proposed idea guides RL agents to learn generalizable features that are more invariant in unseen environments (see Figure 3) than conventional regularization (Srivastava et al., 2014; Ioffe & Szegedy, 2015) and data augmentation (Cobbe et al., 2019; Cubuk et al., 2019) techniques. Here, we also provide an inference technique based on the Monte Carlo approximation, which stabilizes the performance by reducing the variance incurred from our randomization method at test time.
+
+We demonstrate the effectiveness of the proposed method on the 2D CoinRun (Cobbe et al., 2019) game, the 3D DeepMind Lab exploration task (Beattie et al., 2016), and the 3D robotics control task (Fan et al., 2018). For evaluation, the performance of the trained agents is measured in unseen environments with various visual and geometrical patterns (e.g., different styles of backgrounds, objects, and floors), guaranteeing that the trained agents encounter unseen inputs at test time. Note that learning invariant and robust representations against such changes is essential to generalize to unseen environments. In our experiments, the proposed method significantly reduces the generalization gap in unseen environments unlike conventional regularization and data augmentation techniques. For example, compared to the agents learned with the cutout (DeVries & Taylor, 2017) data augmentation methods proposed by Cobbe et al. (2019), our method improves the success rates from $3 9 . 8 \%$ to $5 8 . 7 \%$ under 2D CoinRun, the total score from 55.4 to 358.2 for 3D DeepMind Lab, and the total score from 31.3 to 356.8 for the Surreal robotics control task. Our results can be influential to study other generalization domains, such as tasks with different dynamics (Packer et al., 2018), as well as solving real-world problems, such as sim-to-real transfer (Tobin et al., 2017).
+
+# 2 RELATED WORK
+
+Generalization in deep RL. Recently, the generalization performance of RL agents has been investigated by splitting training and test environments using random seeds (Zhang et al., 2018a) and distinct sets of levels in video games (Machado et al., 2018; Cobbe et al., 2019). Regularization is one of the major directions to improve the generalization ability of deep RL algorithms. Farebrother et al. (2018) and Cobbe et al. (2019) showed that regularization methods can improve the generalization performance of RL agents using various game modes of Atari (Machado et al., 2018) and procedurally generated arcade environments called CoinRun, respectively. On the other hand, data augmentation techniques have also been shown to improve generalization. Tobin et al. (2017) proposed a domain randomization method to generate simulated inputs by randomizing rendering in the simulator. Motivated by this, Cobbe et al. (2019) proposed a data augmentation method by modifying the cutout method (DeVries & Taylor, 2017). Our method can be combined with the prior methods to further improve the generalization performance.
+
+Random networks for deep RL. Random networks have been utilized in several approaches for different purposes in deep RL. Burda et al. (2019) utilized a randomly initialized neural network to define an intrinsic reward for visiting unexplored states in challenging exploration problems. By learning to predict the reward from the random network, the agent can recognize unexplored states. Osband et al. (2018) studied a method to improve ensemble-based approaches by adding a randomized network to each ensemble member to improve the uncertainty estimation and efficient exploration in deep RL. Our method is different because we introduce a random network to improve the generalization ability of RL agents.
+
+Transfer learning. Generalization is also closely related to transfer learning (Parisotto et al., 2016; Rusu et al., 2016a;b), which is used to improve the performance on a target task by transferring the knowledge from a source task. However, unlike supervised learning, it has been observed that finetuning a model pre-trained on the source task for adapting to the target task is not beneficial in deep RL. Therefore, Gamrian & Goldberg (2019) proposed a domain transfer method using generative adversarial networks (Goodfellow et al., 2014) and Farebrother et al. (2018) utilized regularization techniques to improve the performance of fine-tuning methods. Higgins et al. (2017) proposed a multi-stage RL, which learns to extract disentangled representations from the input observation and then trains the agents on the representations. Alternatively, we focus on the zero-shot performance of each agent at test time without further fine-tuning of the agent’s parameters.
+
+# 3 NETWORK RANDOMIZATION TECHNIQUE FOR GENERALIZATION
+
+We consider a standard reinforcement learning (RL) framework where an agent interacts with an   
+environment in discrete time. Formally, at each timestep $t$ , the agent receives a state $s _ { t }$ from the   
+environment2 and chooses an action $r _ { t }$ and the agent transitions to the ncumulated rewards from timestep $a _ { t }$ xt state with a based on its policy $s _ { t + 1 }$ . The retunt factor $\pi$ . The environment returns a reward $\begin{array} { r } { R _ { t } \ = \ \sum _ { k = 0 } ^ { \infty } \gamma ^ { k } r _ { t + k } } \end{array}$ is the totalximizes the $t$ $\gamma \in [ 0 , 1 )$   
+expected return from each state $s _ { t }$ .
+
+# 3.1 TRAINING AGENTS USING RANDOMIZED INPUT OBSERVATIONS
+
+We introduce a random network $f$ with its parameters $\phi$ initialized with a prior distribution, e.g., Xavier normal distribution (Glorot & Bengio, 2010). Instead of the original input $s$ , we train an agent using a randomized input ${ \widehat { s } } = f ( s ; \phi )$ . For example, in the case of policy-based methods,3 the parameters $\theta$ b of the policy network $\pi$ are optimized by minimizing the following policy gradient objective function:
+
+$$
+\mathcal { L } _ { \mathrm { p o l i c y } } ^ { \tt r a n d o m } = \mathbb { E } _ { ( s _ { t } , a _ { t } , R _ { t } ) \in \mathcal { D } } \big [ - \log \pi ( a _ { t } | f ( s _ { t } ; \phi ) ; \theta ) R _ { t } \big ] ,
+$$
+
+where $\mathcal { D } = \{ ( s _ { t } , a _ { t } , R _ { t } ) \}$ is a set of past transitions with cumulative rewards. By re-initializing the parameters $\phi$ of the random network per iteration, the agents are trained using varied and randomized input observations (see Figure 1(a)). Namely, environments are generated with various visual patterns, but with the same semantics by randomizing the networks. Our agents are expected to adapt to new environments by learning invariant representation (see Figure 3 for supporting experiments).
+
+To learn more invariant features, the following feature matching (FM) loss between hidden features from clean and randomized observations is also considered:
+
+$$
+\mathcal { L } _ { \mathtt { F M } } ^ { \mathtt { r a n d o m } } = \mathbb { E } _ { s _ { t } \in \mathcal { D } } \big [ | | h \left( f ( s _ { t } ; \phi ) ; \theta \right) - h \left( s _ { t } ; \theta \right) | | ^ { 2 } \big ] ,
+$$
+
+where $h ( \cdot )$ denotes the output of the penultimate layer of policy $\pi$ . The hidden features from clean and randomized inputs are combined to learn more invariant features against the changes in the input observations.4 Namely, the total loss is:
+
+$$
+\begin{array} { r } { \mathcal { L } ^ { \mathrm { r a n d o m } } = \mathcal { L } _ { \mathrm { p o l i c y } } ^ { \mathrm { r a n d o m } } + \beta \mathcal { L } _ { \mathtt { F M } } ^ { \mathtt { r a n d o m } } , } \end{array}
+$$
+
+where $\beta > 0$ is a hyper-parameter. The full procedure is summarized in Algorithm 1 in Appendix M.
+
+Table 1: The classification accuracy $( \% )$ o n dogs vs. cats dataset. The results show the mean and standard deviation averaged over three runs and the best result is indicated in bold.   
+
+<table><tr><td>Method</td><td colspan="2">Classification Accuracy (%) Train (seen) Test (unseen)</td></tr><tr><td>ResNet-18 ResNet-18 +GR</td><td>95.0± 2.4</td><td>40.3±1.2</td></tr><tr><td></td><td>96.4 ±1.8</td><td>70.9 ±1.7</td></tr><tr><td>ResNet-18 +CO</td><td>95.9 ± 2.3</td><td>41.2 ±1.7</td></tr><tr><td>ResNet-18 +IV</td><td>91.0± 2.0</td><td>47.1 ± 15.1</td></tr><tr><td>ResNet-18 + CJ</td><td>95.2 ±0.6</td><td>43.5± 0.3</td></tr><tr><td>ResNet-18 +ours</td><td>95.9 ± 1.6</td><td>84.4 ± 4.5</td></tr></table>
+
+![](images/bdc4da3ed0c5a1ed709d22b8e7b6383332becd9aa245acb571fcd4d124495d9e.jpg)  
+Figure 2: Samples of dogs vs. cats dataset. The training set consists of bright dogs and dark cats, whereas the test set consists of dark dogs and bright cats.
+
+Details of the random networks. We propose to utilize a single-layer convolutional neural network (CNN) as a random network, where its output has the same dimension with the input (see Appendix $\mathrm { D }$ for additional experimental results on the various types of random networks). To reinitialize the parameters of the random network, we utilize the following mixture of distributions: $\begin{array} { r } { P ( \phi ) = \alpha \mathbb { I } ( \phi = \mathbf { I } ) + ( 1 - \alpha ) \mathcal { N } \left( \mathbf { 0 } ; \sqrt { \frac { 2 } { n _ { \mathrm { i n } } + n _ { \mathrm { o u t } } } } \right) } \end{array}$ , where $\mathbf { I }$ is an identity kernel, $\alpha \in [ 0 , 1 ]$ is a positive constant, $\mathcal { N }$ denotes the normal distribution, and $n _ { \mathrm { i n } } , n _ { \mathrm { o u t } }$ are the number of input and output channels, respectively. Here, clean inputs are used with the probability $\alpha$ because training only randomized inputs can complicate training. The Xavier normal distribution (Glorot & Bengio, 2010) is used for randomization because it maintains the variance of the input $s$ and the randomized input ${ \widehat { s } } .$ We empirically observe that this distribution stabilizes training.
+
+Removing visual bias. To confirm the desired effects of our method, we conduct an image classification experiment on the dogs and cats database from Kaggle.5 Following the same setup as $\operatorname { K i m }$ et al. (2019), we construct datasets with an undesirable bias as follows: the training set consists of bright dogs and dark cats while the test set consists of dark dogs and bright cats (see Appendix H for further details). A classifier is expected to make a decision based on the undesirable bias, (e.g., brightness and color) since CNNs are biased towards texture or color, rather than shape (Geirhos et al., 2019). Table 1 shows that ResNet-18 (He et al., 2016) does not generalize effectively due to overfitting to an undesirable bias in the training data. To address this issue, several image processing methods (Cubuk et al., 2019), such as grayout (GR), cutout (CO; DeVries & Taylor 2017), inversion (IV), and color jitter (CJ), can be applied (see Appendix C for further details). However, they are not effective in improving the generalization ability, compared to our method. This confirms that our approach makes DNNs capture more desired and meaningful information such as the shape by changing the visual appearance of attributes and entities in images while effectively keeping the semantic information. Prior sophisticated methods (Ganin et al., 2016; Kim et al., 2019) require additional information to eliminate such an undesired bias, while our method does not.6 Although we mainly focus on RL applications, our idea can also be explorable in this direction.
+
+# 3.2 INFERENCE METHODS FOR SMALL VARIANCE
+
+Since the parameter of random networks is drawn from a prior distribution $P ( \phi )$ , our policy is   
+modeled by a stochastic neural network: $\pi ( a | s ; \theta ) = \mathbb { E } _ { \phi } { \bigl [ } \pi \left( a | f \left( s ; \phi \right) ; \theta \right) { \bigr ] }$ . Based on this inter  
+pretation, our training procedure (i.e., randomizing the parameters) consists of training stochastic   
+models using the Monte Carlo (MC) approximation (with one sample per iteration). Therefore, $a$ taken b, where g the and pectations as follows:is the number of MC   
+$\begin{array} { r } { \pi \left( a | s ; \theta \right) \simeq \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \pi \left( a \Big | f \left( s ; \phi ^ { ( m ) } \right) ; \theta \right) } \end{array}$ $\phi ^ { ( m ) } \sim P \left( \phi \right)$ $M$ $M$   
+their decisions. The results show that this estimator improves the performance of the trained agents   
+by approximating the posterior distribution more accurately (see Figure 3(d)).
+
+# 4 EXPERIMENTS
+
+In this section, we demonstrate the effectiveness of the proposed method on 2D CoinRun (Cobbe et al., 2019), 3D DeepMind Lab exploration (Beattie et al., 2016), and 3D robotics control task (Fan et al., 2018). To evaluate the generalization ability, we measure the performance of trained agents in unseen environments which consist of different styles of backgrounds, objects, and floors. Due to the space limitation, we provide more detailed experimental setups and results in the Appendix.
+
+# 4.1 BASELINES AND IMPLEMENTATION DETAILS
+
+For CoinRun and DeepMind Lab experiments, similar to Cobbe et al. (2019), we take the CNN architecture used in IMPALA (Espeholt et al., 2018) as the policy network, and the Proximal Policy Optimization (PPO) (Schulman et al., 2017) method to train the agents.7 At each timestep, agents are given an observation frame of size $6 4 \times 6 4$ as input (resized from the raw observation of size $3 2 0 \times 2 4 0$ as in the DeepMind Lab), and the trajectories are collected with the 256-step rollout for training. For Surreal robotics experiments, similar to Fan et al. (2018), the hybrid of CNN and long short-term memory (LSTM) architecture is taken as the policy network, and a distributed version of PPO (i.e., actors collect a massive amount of trajectories, and the centralized learner updates the model parameters using PPO) is used to train the agents.8 We measure the performance in the unseen environment for every 10M timesteps and report the mean and standard deviation across three runs.
+
+Our proposed method, which augments PPO with random networks and feature matching (FM) loss (denoted $\mathrm { P P O + }$ ours), is compared with several regularization and data augmentation methods. As regularization methods, we compare dropout (DO; Srivastava et al. 2014), L2 regularization (L2), and batch normalization (BN; Ioffe & Szegedy 2015). For those methods, we use the hyperparameters suggested in Cobbe et al. (2019), which are empirically shown to be effective: a dropout probability of 0.1 and a coefficient of $1 0 ^ { - 4 }$ for L2 regularization. We also consider various data augmentation methods: a variant of cutout (CO; DeVries & Taylor 2017) proposed in Cobbe et al. (2019), grayout (GR), inversion (IV), and color jitter (CJ) by adjusting brightness, contrast, and saturation (see Appendix $\mathrm { C }$ for more details). As an upper bound, we report the performance of agents trained directly on unseen environments, dented PPO (oracle). For our method, we use $\beta = 0 . 0 0 2$ for the weight of the FM loss, $\alpha = 0 . 1$ for the probability of skipping the random network, $M = 1 0$ for MC approximation, and a single-layer CNN with the kernel size of 3 as a random network.
+
+# 4.2 EXPERIMENTS ON COINRUN
+
+Task description. In this task, an agent is located at the leftmost side of the map and the goal is to collect the coin located at the rightmost side of the map within 1,000 timesteps. The agent observes its surrounding environment in the third-person point of view, where the agent is always located at the center of the observation. CoinRun contains an arbitrarily large number of levels which are generated deterministically from a given seed. In each level, the style of background, floor, and obstacles is randomly selected from the available themes (34 backgrounds, 6 grounds, 5 agents, and 9 moving obstacles). Some obstacles and pitfalls are distributed between the agent and the coin, where a collision with them results in the agent’s immediate death. We measure the success rates, which correspond to the number of collected coins divided by the number of played levels.
+
+Ablation study on small-scale environments. First, we train agents on one level for 100M timesteps and measure the performance in unseen environments by only changing the style of the background, as shown in Figure 3(a). Note that these visual changes are not significant to the game’s dynamics, but the agent should achieve a high success rate if it can generalize accurately. However, Table 2 shows that all baseline agents fail to generalize to unseen environments, while they achieve a near-optimal performance in the seen environment. This shows that regularization techniques have no significant impact on improving the generalization ability. Even though data augmentation techniques, such as cutout (CO) and color jitter (CJ), slightly improve the performance, our proposed method is most effective because it can produce a diverse novelty in attributes and entities. Training with randomized inputs can degrade the training performance, but the high expressive power of DNNs prevents from it. The performance in unseen environments can be further improved by optimizing the FM loss. To verify the effectiveness of MC approximation at test time, we measure the performance in unseen environments by varying the number of MC samples. Figure 3(d) shows the mean and standard deviation across 50 evaluations. The performance and its variance can be improved by increasing the number of MC samples, but the improvement is saturated around ten samples. Thus, we use ten samples for the following experiments.
+
+<table><tr><td rowspan="2"></td><td rowspan="2"></td><td>PPO</td><td>PPO +DO</td><td>PPO +L2</td><td>PPO +BN</td><td>PPO +CO</td><td>PPO +IV</td><td>PPO +GR</td><td>PPO +CJ</td><td colspan="2">PPO +ours</td></tr><tr><td>100</td><td>100</td><td>98.3</td><td>93.3</td><td>100</td><td>95.0</td><td>100</td><td>100</td><td>Rand 95.0</td><td>Rand + FM 100</td></tr><tr><td rowspan="2">Success rate</td><td>Seen</td><td>±0.0 34.6</td><td>±0.0 25.3</td><td>±2.9 34.1</td><td>±11.5 31.5</td><td>±0.0 41.9</td><td>±8.6 37.5</td><td>±0.0 26.9</td><td>±0.0 43.1</td><td>±7.1 76.7</td><td>±0.0 78.1</td></tr><tr><td>Unseen</td><td>±4.5</td><td>±12.0</td><td>±5.4</td><td>±13.1</td><td>±5.5</td><td>±0.8</td><td>±13.1</td><td>±1.4</td><td>±1.3</td><td>±3.5</td></tr><tr><td rowspan="2">Cycle- consistency</td><td>2-way</td><td>18.9 ±10.9</td><td>13.3 ±2.2</td><td>24.4 ±1.1</td><td>25.5 ±6.6</td><td>27.8 ±10.6</td><td>17.8 ±15.6</td><td>17.7 ±1.1</td><td>32.2 ±3.1</td><td>64.7 ±4.4</td><td>67.8 ±6.2</td></tr><tr><td>3-way</td><td>4.4 ±2.2</td><td>4.4 ±2.2</td><td>8.9 士3.8</td><td>7.4 ±1.2</td><td>9.6 ±5.6</td><td>5.6 土4.7</td><td>2.2 ±3.8</td><td>15.6 ±3.1</td><td>39.3 ±8.5</td><td>43.3 土4.7</td></tr></table>
+
+![](images/899c1c24109e49594620b6ee4a18f166a2b339071f2581d16ed3de8924ed37a7.jpg)  
+Table 2: Success rate $( \% )$ and cycle-consistency $( \% )$ after 100M timesteps in small-scale CoinRun. The results show the mean and standard deviation averaged over three runs and the best results are indicated in bold.   
+Figure 3: (a) We collect multiple episodes from various environments by human demonstrators and visualize the hidden representation of trained agents optimized by (b) PPO and (c) $\mathrm { P P O } +$ ours constructed by t-SNE, where the colors of points indicate the environments of the corresponding observations. (d) Average success rates for varying number of MC samples.
+
+Embedding analysis. We analyze whether the hidden representation of trained RL agents exhibits meaningful abstraction in the unseen environments. The features on the penultimate layer of trained agents are visualized and reduced to two dimensions using t-SNE (Maaten & Hinton, 2008). Figure 3 shows the projection of trajectories taken by human demonstrators in seen and unseen environments (see Figure 17 in Appendix $_ \mathrm { N }$ for further results). Here, trajectories from both seen and unseen environments are aligned on the hidden space of our agents, while the baselines yield scattered and disjointed trajectories. This implies that our method makes RL agents capable of learning the invariant and robust representation.
+
+To evaluate the quality of hidden representation quantitatively, the cycle-consistency proposed in Aytar et al. (2018) is also measured. Given two trajectories $V$ and $U$ , $v _ { i } ~ \in ~ V$ first locates its nearest neighbor in the other trajectory $\begin{array} { r } { u _ { j } = \arg \operatorname* { m i n } _ { u \in U } \left\| h ( v _ { i } ) - h ( u ) \right\| ^ { 2 } } \end{array}$ , where $h ( \cdot )$ denotes the output of the penultimate layer of trained agents. Then, the nearest neighbor of $u _ { j }$ in $V$ is located, i.e., $v _ { k } = { \mathrm { a r g } } \operatorname* { m i n } _ { v \in V } \left\| h ( v ) - h ( u _ { j } ) \right\| ^ { 2 }$ , and $v _ { i }$ is defined as cycle-consistent if $| i - k | \leq 1$ , i.e., it can return to the original point. Note that this cycle-consistency implies that two trajectories are accurately aligned in the hidden space. Similar to Aytar et al. (2018), we also evaluate the three-way cycle-consistency by measuring whether $v _ { i }$ remains cycle-consistent along both paths, $V \to U \to J \to V$ and $V \to J \to U \to V$ , where $J$ is the third trajectory. Using the trajectories shown in Figure 3(a), Table 2 reports the percentage of input observations in the seen environment (blue curve) that are cycle-consistent with unseen trajectories (red and green curves). Similar to the results shown in Figure 3(c), our method significantly improves the cycle-consistency compared to the vanilla PPO agent.
+
+![](images/2bd5df39e3a1152c71a851a278eb1bf97ec9439e0e536d969a1349bde70dec54.jpg)  
+Figure 4: Visualization of activation maps via Grad-CAM in seen and unseen environments in the small-scale CoinRun. Images are aligned with similar states from various episodes for comparison.
+
+![](images/c0d927ca2172cfe374c438b2fec295ca008e55d6e32c8a83a6738ae5e8b6ac73.jpg)  
+Figure 5: The performances of trained agents in unseen environments under (a) large-scale CoinRun, (b) DeepMind Lab and (c) Surreal robotics control. The solid/dashed lines and shaded regions represent the mean and standard deviation, respectively.
+
+Visual interpretation. To verify whether the trained agents can focus on meaningful and highlevel information, the activation maps are visualized using Grad-CAM (Selvaraju et al., 2017) by averaging activations channel-wise in the last convolutional layer, weighted by their gradients. As shown in Figure 4, both vanilla PPO and our agents make a decision by focusing on essential objects, such as obstacles and coins in the seen environment. However, in the unseen environment, the vanilla PPO agent displays a widely distributed activation map in some cases, while our agent does not. As a quantitative metric, we measure the entropy of normalized activation maps. Specifically, we first normalize activations $\sigma _ { t , h , w } \in [ 0 , 1 ]$ , such that it represents a 2D discrete probability distribution at timestep as follow $t$ , i: $\begin{array} { r } { \sum _ { h = 1 } ^ { H } \sum _ { w = 1 } ^ { W } \sigma _ { t , h , w } = 1 } \end{array}$ asure the entropy averaged over the timesteps. Note that the entropy of the activation map $\begin{array} { r } { - \frac { 1 } { T } \sum _ { t = 1 } ^ { T } \sum _ { h = 1 } ^ { H } \sum _ { w = 1 } ^ { W } \ \sigma _ { t , h , w } \log \sigma _ { t , h , w } } \end{array}$ quantitatively measures the frequency an agent focuses on salient components in its observation. Results show that our agent produces a low entropy on both seen and unseen environments (i.e., 2.28 and 2.44 for seen and unseen, respectively), whereas the vanilla PPO agent produces a low entropy only in the seen environment (2.77 and 3.54 for seen and unseen, respectively).
+
+Results on large-scale experiments. Similar to Cobbe et al. (2019), the generalization ability by training agents is evaluated on a fixed set of 500 levels of CoinRun. To explicitly separate seen and unseen environments, half of the available themes are utilized (i.e., style of backgrounds, floors, agents, and moving obstacles) for training, and the performances on 1,000 different levels consisting of unseen themes are measured.9 As shown in Figure 5(a), our method outperforms all baseline methods by a large margin. In particular, the success rates are improved from $3 9 . 8 \%$ to $5 8 . 7 \%$ compared to the PPO with cutout (CO) augmentation proposed in Cobbe et al. (2019), showing that our agent learns generalizable representations given a limited number of seen environments.
+
+<table><tr><td rowspan="3"></td><td colspan="4">PPO</td><td colspan="2">PPO + ours</td></tr><tr><td>#of Seen Environments</td><td>Total Rewards</td><td>#of Seen Environments</td><td>Total Rewards</td><td>#of Seen Environments</td><td>Total Rewards</td></tr><tr><td>DeepMind Lab</td><td>1</td><td>55.4±33.2</td><td>16</td><td>218.3± 99.2</td><td>1</td><td>358.2±81.5</td></tr><tr><td>Surreal Robotics</td><td>1</td><td>59.2 ± 31.9</td><td>25</td><td>168.8 ± 155.8</td><td>1</td><td>356.8± 15.4</td></tr></table>
+
+Table 3: Comparison with domain randomization. The results show the mean and standard deviation averaged over three runs and the best results are indicated in bold.
+
+# 4.3 EXPERIMENTS ON DEEPMIND LAB AND SURREAL ROBOTICS CONTROL
+
+Results on DeepMind Lab. We also demonstrate the effectiveness of our proposed method on DeepMind Lab (Beattie et al., 2016), which is a 3D game environment in the first-person point of view with rich visual inputs. The task is designed based on the standard exploration task, where a goal object is placed in one of the rooms in a 3D maze. In this task, agents aim to collect as many goal objects as possible within 90 seconds to maximize their rewards. Once the agent collects the goal object, it receives ten points and is relocated to a random place. Similar to the small-scale CoinRun experiment, agents are trained to collect the goal object in a fixed map layout and tested in unseen environments with only changing the style of the walls and floors. We report the mean and standard deviation of the average scores across ten different map layouts, which are randomly selected. Additional details are provided in Appendix G.
+
+Note that a simple strategy of exploring the map actively and recognizing the goal object achieves high scores because the maze size is small in this experiment. Even though the baseline agents achieve high scores by learning this simple strategy in the seen environment (see Figure 6(c) in Appendix A for learning curves), Figure 5(b) shows that they fail to adapt to the unseen environments. However, the agent trained by our proposed method achieves high scores in both seen and unseen environments. These results show that our method can learn generalizable representations from high-dimensional and complex input observations (i.e., 3D environment).
+
+Results on Surreal robotics control. We evaluate our method in the Block Lifting task using the Surreal distributed RL framework (Fan et al., 2018): the Sawyer robot receives a reward if it succeeds to lift a block randomly placed on a table. We train agents on a single environment and test on five unseen environments with various styles of tables and blocks (see Appendix I for further details). Figure 5(c) shows that our method achieves a significant performance gain compared to all baselines in unseen environments while maintaining its performance in the seen environment (see Figure 13 in Appendix I), implying that our method can maintain essential properties, such as structural spatial features of the input observation.
+
+Comparison with domain randomization. To further verify the effectiveness of our method, the vanilla PPO agents are trained by increasing the number of seen environments generated by randomizing rendering in a simulator, while our agent is still trained in a single environment (see Appendices $\mathbf { G }$ and I for further details). Table 3 shows that the performance of baseline agents can be improved with domain randomization (Tobin et al., 2017). However, our method still outperforms the baseline methods trained with more diverse environments than ours, implying that our method is more effective in learning generalizable representations than simply increasing the (finite) number of seen environments.
+
+# 5 CONCLUSION
+
+In this paper, we explore generalization in RL where the agent is required to generalize to new environments in unseen visual patterns, but semantically similar. To improve the generalization ability, we propose to randomize the first layer of CNN to perturb low-level features, e.g., various textures, colors, or shapes. Our method encourages agents to learn invariant and robust representations by producing diverse visual input observations. Such invariant features could be useful for several other related topics, like an adversarial defense in RL (see Appendix B for further discussions), sim-to-real transfer (Tobin et al., 2017; Ren et al., 2019), transfer learning (Parisotto et al., 2016; Rusu et al., 2016a;b), and online adaptation (Nagabandi et al., 2019). We provide the more detailed discussions on an extension to the dynamics generalization and failure cases of our method in Appendix J and K, respectively.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported in part by Kwanjeong Educational Foundation Scholarship and Sloan Research Fellowship. We also thank Sungsoo Ahn, Jongwook Choi, Wilka Carvalho, Yijie Guo, Yunseok Jang, Lajanugen Logeswaran, Sejun Park, Sungryull Sohn, Ruben Villegas, and Xinchen Yan for helpful discussions.
+
+# REFERENCES
+
+Yusuf Aytar, Tobias Pfaff, David Budden, Thomas Paine, Ziyu Wang, and Nando de Freitas. Playing hard exploration games by watching youtube. In NeurIPS, 2018.
+
+Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler,¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. Deepmind lab. ´ arXiv preprint arXiv:1612.03801, 2016.
+
+Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. In ICLR, 2019.
+
+Bibhas Chakraborty and Susan A Murphy. Dynamic treatment regimes. Annual review of statistics and its application, 1:447–464, 2014.
+
+Karl Cobbe, Oleg Klimov, Chris Hesse, Taehoon Kim, and John Schulman. Quantifying generalization in reinforcement learning. In ICML, 2019.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. In CVPR, 2019.
+
+Yue Deng, Feng Bao, Youyong Kong, Zhiquan Ren, and Qionghai Dai. Deep direct reinforcement learning for financial signal representation and trading. IEEE transactions on neural networks and learning systems, 28(3):653–664, 2016.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. In ICML, 2018.
+
+Linxi Fan, Yuke Zhu, Jiren Zhu, Zihua Liu, Orien Zeng, Anchit Gupta, Joan Creus-Costa, Silvio Savarese, and Li Fei-Fei. Surreal: Open-source reinforcement learning framework and robot manipulation benchmark. In CoRL, 2018.
+
+Jesse Farebrother, Marlos C Machado, and Michael Bowling. Generalization and regularization in dqn. arXiv preprint arXiv:1810.00123, 2018.
+
+Shani Gamrian and Yoav Goldberg. Transfer learning for related reinforcement learning tasks via image-to-image translation. In ICML, 2019.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 2016.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. In ICLR, 2019.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NeurIPS, 2014.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In ICML, 2017.
+
+Sandy Huang, Nicolas Papernot, Ian Goodfellow, Yan Duan, and Pieter Abbeel. Adversarial attacks on neural network policies. arXiv preprint arXiv:1702.02284, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Byungju Kim, Hyunwoo Kim, Kyungsu Kim, Sungjin Kim, and Junmo Kim. Learning not to learn: Training deep neural networks with biased data. In CVPR, 2019.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Yen-Chen Lin, Zhang-Wei Hong, Yuan-Hong Liao, Meng-Li Shih, Ming-Yu Liu, and Min Sun. Tactics of adversarial attack on deep reinforcement learning agents. In IJCAI, 2017.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
+
+Marlos C Machado, Marc G Bellemare, Erik Talvitie, Joel Veness, Matthew Hausknecht, and Michael Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Anusha Nagabandi, Chelsea Finn, and Sergey Levine. Deep online learning via meta-learning: Continual adaptation for model-based rl. In ICLR, 2019.
+
+Ian Osband, John Aslanides, and Albin Cassirer. Randomized prior functions for deep reinforcement learning. In NeurIPS, 2018.
+
+Charles Packer, Katelyn Gao, Jernej Kos, Philipp Krahenb ¨ uhl, Vladlen Koltun, and Dawn Song. ¨ Assessing generalization in deep reinforcement learning. arXiv preprint arXiv:1810.12282, 2018.
+
+Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In ICLR, 2016.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In ICRA, 2018.
+
+Xinyi Ren, Jianlan Luo, Eugen Solowjow, Juan Aparicio Ojea, Abhishek Gupta, Aviv Tamar, and Pieter Abbeel. Domain randomization for active pose estimation. In ICRA, 2019.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. In ICLR, 2016a.
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016b.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In NeurIPS, 2016.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In ICML, 2015.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. In ICLR, 2016.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In ICCV, 2017.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140– 1144, 2018.
+
+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.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In IROS, 2017.
+
+Oriol Vinyals, Timo Ewalds, Sergey Bartunov, Petko Georgiev, Alexander Sasha Vezhnevets, Michelle Yeo, Alireza Makhzani, Heinrich Kuttler, John Agapiou, Julian Schrittwieser, et al. ¨ Starcraft ii: A new challenge for reinforcement learning. arXiv preprint arXiv:1708.04782, 2017.
+
+Jane X Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z Leibo, Remi Munos, Charles Blundell, Dharshan Kumaran, and Matt Botvinick. Learning to reinforcement learn. arXiv preprint arXiv:1611.05763, 2016.
+
+Ronald J Williams and Jing Peng. Function optimization using connectionist reinforcement learning algorithms. Connection Science, 3(3):241–268, 1991.
+
+Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation. arXiv preprint arXiv:1904.12848, 2019.
+
+Amy Zhang, Nicolas Ballas, and Joelle Pineau. A dissection of overfitting and generalization in continuous reinforcement learning. arXiv preprint arXiv:1806.07937, 2018a.
+
+Chiyuan Zhang, Oriol Vinyals, Remi Munos, and Samy Bengio. A study on overfitting in deep reinforcement learning. arXiv preprint arXiv:1804.06893, 2018b.
+
+Wenxuan Zhou, Lerrel Pinto, and Abhinav Gupta. Environment probing interaction policies. In ICLR, 2019.
+
+# Appendix: Network Randomization: A Simple Technique for Generalization in Deep Reinforcement Learning
+
+# A LEARNING CURVES
+
+![](images/b90ec93ce6823f184b9a178c82742369dfce40cf32b81eb9333244a6a8eeb608.jpg)  
+Figure 6: Learning curves on (a) small-scale, (b) large-scale CoinRun and (c) DeepMind Lab. The solid line and shaded regions represent the mean and standard deviation, respectively, across three runs.
+
+![](images/b9331334b2ad06964dde7844e75095d23bc469295993b11a8c8e08bba472c4a0.jpg)  
+Figure 7: The performance in unseen environments in small-scale CoinRun. The solid/dashed line and shaded regions represent the mean and standard deviation, respectively, across three runs.
+
+# B ROBUSTNESS AGAINST ADVERSARIAL ATTACKS
+
+The adversarial (visually imperceptible) perturbation (Szegedy et al., 2014) to clean input observations can induce the DNN-based policies to generate an incorrect decision at test time (Huang et al., 2017; Lin et al., 2017). This undesirable property of DNNs has raised major security concerns. In this section, we evaluate if the proposed method can improve the robustness on adversarial attacks. Our method is expected to improve the robustness against such adversarial attacks because the agents are trained with randomly perturbed inputs. To verify that the proposed method can improve the robustness to adversarial attacks, the adversarial samples are generated using FGSM (Goodfellow et al., 2015) by perturbing inputs to the opposite direction to the most probable action initially predicted by the policy:
+
+$$
+s _ { \mathrm { a d v } } = s - \varepsilon \mathrm { s i g n } \left( \nabla _ { s } \log \pi ( a ^ { * } | s ; \theta ) \right) ,
+$$
+
+where $\varepsilon$ is the magnitude of noise and $a ^ { * } = \arg \operatorname* { m a x } _ { a } \pi ( a | s ; \theta )$ is the action from the policy. Table 4 shows that our proposed method can improve the robustness against FGSM attacks with $\varepsilon = 0 . 0 1$ , which implies that hidden representations of trained agents are more robust.
+
+<table><tr><td rowspan="2"></td><td colspan="2">Small-Scale CoinRun</td><td colspan="2">Large-Scale CoinRun</td><td colspan="2">DeepMind Lab</td></tr><tr><td>Clean</td><td>FGSM</td><td>Clean</td><td>FGSM</td><td>Clean</td><td>FGSM</td></tr><tr><td>PPO</td><td>100</td><td>61.5 (-38.5)</td><td>96.2</td><td>77.4 (-19.5)</td><td>352.5</td><td>163.5 (-53.6)</td></tr><tr><td>PPO +ours</td><td>100</td><td>88.0 (-12.0)</td><td>99.6</td><td>84.4 (-15.3)</td><td>368.0</td><td>184.0 (-50.0)</td></tr></table>
+
+Table 4: Robustness against FGSM attacks on training environments. The values in parentheses represent the relative reductions from the clean samples.
+
+# C DETAILS FOR TRAINING AGENTS USING PPO
+
+Policy optimization. For all baselines and our methods, PPO is utilized to train the policies. Specifically, we use a discount factor $\gamma = 0 . 9 9 9$ , a generalized advantage estimator (GAE) Schulman et al. (2016) parameter $\lambda = 0 . 9 5$ , and an entropy bonus (Williams & Peng, 1991) of 0.01 to ensure sufficient exploration. We extract 256 timesteps per rollout, and then train the agent for 3 epochs with 8 mini-batches. The Adam optimizer (Kingma & Ba, 2015) is used with the starting learning rate 0.0005. We run 32 environments simultaneously during training. As suggested in Cobbe et al. (2019), two boxes are painted in the upper-left corner, where their color represents the $x \cdot$ - and $y$ -axis velocity to help the agents quickly learn to act optimally. In this way, the agent does not need to memorize previous states, so a simple CNN-based policy without LSTM can effectively perform in our experimental settings.
+
+Data augmentation methods. In this paper, we compare a variant of cutout (DeVries & Taylor, 2017) proposed in Cobbe et al. (2019), grayout, inversion, and color jitter (Cubuk et al., 2019). Specifically, the cutout augmentation applies a random number of boxes in random size and color to the input, the grayout method averages all three channels of the input, the inversion method inverts pixel values by a $50 \%$ chance, and the color jitter changes the characteristics of images commonly used for data augmentation in computer vision tasks: brightness, contrast, and saturation. For every timestep in the cutout augmentation, we first randomly choose the number of boxes from zero to five, assign them a random color and size, and place them in the observation. For the color jitter, the parameters for brightness, contrast, and saturation are randomly chosen in [0.5,1.5].10 For each episode, the parameters of these methods are randomized and fixed such that the same image preprocessing is applied within an episode.
+
+# D DIFFERENT TYPES OF RANDOM NETWORKS
+
+In this section, we apply random networks to various locations in the network architecture (see Figure 9) and measure the performance in large-scale CoinRun without the feature matching loss. For all methods, a single-layer CNN is used with a kernel size of 3, and its output tensor is padded in order to be in the same dimension as the input tensor. As shown in Figure 8, the performance of unseen environments decreases as the random network is placed in higher layers. On the other hand, the random network in residual connections improves the generalization performance, but it does not outperform the case when a random network is placed at the beginning of the network, meaning that randomizing only the local features of inputs can be effective for a better generalization performance.
+
+![](images/785843beba5230d2cbe6aa12945f071e3aae3f42ef74c65d50d73398af11cc5b.jpg)  
+Figure 8: The performance of random networks in various locations in the network architecture on (a) seen and (b) unseen environments in large-scale CoinRun. We show the mean performances averaged over three different runs, and shaded regions represent the standard deviation.
+
+![](images/4c95d57a54400c69c292624f30fe656f81818798462b57f5924d8bbd4543ed9f.jpg)  
+Figure 9: Network architectures with random networks in various locations. Only convolutional layers and the last fully connected layer are displayed for conciseness.
+
+# E ENVIRONMENTS IN SMALL-SCALE COINRUN
+
+For small-scale CoinRun environments, we consider a fixed map layout with two moving obstacles and measure the performance of the trained agents by changing the style of the backgrounds (see Figure 10). Below is the list of seen and unseen backgrounds in this experiment:
+
+◦ Seen background:
+
+![](images/12430d034930e5313959896f962d8fa27b657066dc59e0b9f218df08c3549f52.jpg)  
+Figure 10: Examples of seen and unseen environments in small-scale CoinRun.
+
+• kenney/Backgrounds/blue_desert.png
+
+# ◦ Unseen backgrounds:
+
+• kenney/Backgrounds/colored_desert.png   
+• kenney/Backgrounds/colored_grass.png backgrounds/game-backgrounds/seabed.png backgrounds/game-backgrounds/G049_OT000_002A__background.png backgrounds/game-backgrounds/Background.png   
+• backgrounds/game-backgrounds/Background (4).png   
+• backgrounds/game-backgrounds/BG_only.png   
+• backgrounds/game-backgrounds/bg1.png   
+• backgrounds/game-backgrounds/G154_OT000_002A__background.png   
+• backgrounds/game-backgrounds/Background (5).png backgrounds/game-backgrounds/Background (2).png backgrounds/game-backgrounds/Background (3).png   
+• backgrounds/background-from-glitch-assets/background.png   
+• backgrounds/spacebackgrounds-0/deep_space_01.png   
+• backgrounds/spacebackgrounds-0/spacegen_01.png   
+• backgrounds/spacebackgrounds-0/milky_way_01.png   
+• backgrounds/spacebackgrounds-0/deep_sky_01.png   
+• backgrounds/spacebackgrounds-0/space_nebula_01.png   
+• backgrounds/space-backgrounds-3/Background-1.png backgrounds/space-backgrounds-3/Background-2.png   
+• backgrounds/space-backgrounds-3/Background-3.png   
+• backgrounds/space-backgrounds-3/Background-4.png   
+• backgrounds/background-2/airadventurelevel1.png   
+• backgrounds/background-2/airadventurelevel2.png   
+• backgrounds/background-2/airadventurelevel3.png   
+• backgrounds/background-2/airadventurelevel4.png
+
+# F ENVIRONMENTS IN LARGE-SCALE COINRUN
+
+In CoinRun, there are 34 themes for backgrounds, 6 for grounds, 5 for agents, and 9 for obstacles. For the large-scale CoinRun experiment, we train agents on a fixed set of 500 levels of CoinRun using half of the available themes and measure the performances on 1,000 different levels consisting of unseen themes. Specifically, the following is a list of seen and unseen themes used in this experiment:
+
+◦ Seen backgrounds:
+
+• kenney/Backgrounds/blue_desert.png • kenney/Backgrounds/blue_grass.png • kenney/Backgrounds/blue_land.png • kenney/Backgrounds/blue_shroom.png
+
+![](images/8161658d3bf5f790823af97f7fe9b960f956bbf0dc85ceb6af6cc3d459c5053f.jpg)  
+Figure 11: Examples of seen and unseen environments in large-scale CoinRun.
+
+• kenney/Backgrounds/colored_desert.png   
+• kenney/Backgrounds/colored_grass.png   
+• kenney/Backgrounds/colored_land.png   
+• backgrounds/game-backgrounds/seabed.png   
+• backgrounds/game-backgrounds/G049_OT000_002A__background.png backgrounds/game-backgrounds/Background.png   
+• backgrounds/game-backgrounds/Background (4).png   
+backgrounds/game-backgrounds/BG_only.png backgrounds/game-backgrounds/bg1.png   
+• backgrounds/game-backgrounds/G154_OT000_002A__background.png   
+• backgrounds/game-backgrounds/Background (5).png   
+• backgrounds/game-backgrounds/Background (2).png   
+• backgrounds/game-backgrounds/Background (3).png
+
+# ◦ Unseen backgrounds:
+
+• backgrounds/background-from-glitch-assets/background.png • backgrounds/spacebackgrounds-0/deep_space_01.png • backgrounds/spacebackgrounds-0/spacegen_01.png • backgrounds/spacebackgrounds-0/milky_way_01.png backgrounds/spacebackgrounds-0/ez_space_lite_01.png backgrounds/spacebackgrounds-0/meyespace_v1_01.png • backgrounds/spacebackgrounds-0/eye_nebula_01.png • backgrounds/spacebackgrounds-0/deep_sky_01.png • backgrounds/spacebackgrounds-0/space_nebula_01.png • backgrounds/space-backgrounds-3/Background-1.png • backgrounds/space-backgrounds-3/Background-2.png • backgrounds/space-backgrounds-3/Background-3.png
+
+• backgrounds/space-backgrounds-3/Background-4.png • backgrounds/background-2/airadventurelevel1.png • backgrounds/background-2/airadventurelevel2.png • backgrounds/background-2/airadventurelevel3.png • backgrounds/background-2/airadventurelevel4.png
+
+◦ Seen grounds:
+
+• Dirt • Grass • Planet ◦ Unseen grounds:
+
+• Sand • Snow • Stone
+
+◦ Seen player themes:
+
+• Beige • Blue
+
+◦ Unseen player themes:
+
+• Green • Pink • Yellow
+
+![](images/8c058a2847d7f7a4670c6fe644256dc47a3494b27648100fd22ca9e882f4ec69.jpg)  
+Figure 12: The top-down view of the trained map layouts.
+
+# G ENVIRONMENTS ON DEEPMIND LAB
+
+Dataset. Among the styles (textures and colors) provided for the 3D maze in the DeepMind Lab, we take ten different styles of floors and walls, respectively (see the list below). We construct a training dataset by randomly choosing a map layout and assigning a theme among ten floors and walls, respectively. The domain randomization method compared in Table 3 uses four floors and four wall themes (16 combinations in total). Trained themes are randomly chosen before training and their combinations are considered to be seen environments. To evaluate the generalization ability, we measure the performance of trained agents on unseen environments by changing the styles of walls and floors. Domain randomization has more seen themes than the other methods, so all methods are compared with six floors and six walls (36 combinations in total), which are unseen for all methods. The mean and standard deviation of the average scores across ten different map layouts are reported in Figure 12.
+
+# ◦ Floor themes:
+
+• lg_style_01_floor_orange • lg_style_01_floor_blue • lg_style_02_floor_blue • lg_style_02_floor_green • lg_style_03_floor_green • lg_style_03_floor_blue • lg_style_04_floor_blue • lg_style_04_floor_orange • lg_style_05_floor_blue • lg_style_05_floor_orange
+
+# ◦ Wall themes:
+
+• lg_style_01_wall_green • lg_style_01_wall_red lg_style_02_wall_yellow lg_style_02_wall_blue lg_style_03_wall_orange lg_style_03_wall_gray lg_style_04_wall_green lg_style_04_wall_red lg_style_05_wall_red • lg_style_05_wall_yellow
+
+Action space. Similar to IMPALA (Espeholt et al., 2018), the agent can take eight actions from the DeepMind Lab native action samples: {Forward, Backward, Move Left, Move Right, Look Left, Look Right, Forward $^ +$ Look Left, and Forward $^ +$ Look Right}. Table 5 describes the detailed mapping.
+
+<table><tr><td>Action</td><td>DeepMind Lab Native Action</td></tr><tr><td>Forward</td><td>0， 0， 0， 1， 0 ，</td></tr><tr><td>Backward</td><td>[ [ 0， 0， 0， -1， 0， 1</td></tr><tr><td>Move Left</td><td>0， 0， -1， 0，</td></tr><tr><td>Move Right</td><td>0， 0， 1， 0，</td></tr><tr><td>Look Left</td><td>[-20， 0， 0， 0，</td></tr><tr><td>Look Right</td><td>【20， 0， 0， 0，</td></tr><tr><td>Forward +LookLeft</td><td>[-20， 0， 0， 1，</td></tr><tr><td>Forward + Look Right</td><td>【20， 0， 0， 1，</td></tr></table>
+
+Table 5: Action set used in the DeepMind Lab experiment. The DeepMind Lab native action set consists of seven discrete actions encoded in integers ([L,U] indicates the lower/upper bound of the possible values): 1) yaw (left/right) rotation by pixel [-512,512], 2) pitch (up/down) rotation by pixel [-512,512], 3) horizontal move [-1,1], 4) vertical move [-1,1], 5) fire [0,1], 6) jump [0,1], and 7) crouch [0,1].
+
+# H EXPERIMENTS ON DOGS AND CATS DATABASE
+
+Dataset. The original database is a set of 25,000 images of dogs and cats for training and 12,500 images for testing. Similar to Kim et al. (2019), the data is manually categorized according to the color of the animal: bright or dark. Biased datasets are constructed such that the training set consists of bright dogs and dark cats, while the test and validation sets contain dark dogs and bright cats. Specifically, training, validation, and test sets consist of 10,047, 1,000, and 5,738 images, respectively.11 ResNet-18 (He et al., 2016) is trained with an initial learning rate chosen from $\left. 0 . 0 5 , \bar { 0 } . 1 \right.$
+
+and then dropped by 0.1 at 50 epochs with a total of 100 epochs. We use the Nesterov momentum of 0.9 for SGD, a mini-batch size chosen from $\{ 3 2 , 6 4 \}$ , and the weight decay set to 0.0001. We report the training and test set accuracies with the hyperparameters chosen by validation. Unlike Kim et al. (2019), we do not use ResNet-18 pre-trained with ImageNet (Russakovsky et al., 2015) in order to avoid inductive bias from the pre-trained dataset.
+
+# I EXPERIMENTAL RESULTS ON SURREAL ROBOT MANIPULATION
+
+Our method is evaluated in the Block Lifting task using the Surreal distributed RL framework (Fan et al., 2018). In this task, the Sawyer robot receives a reward if it successfully lifts a block randomly placed on a table. Following the experimental setups in (Fan et al., 2018), the hybrid CNN-LSTM architecture (see Figure 13(a)) is chosen as the policy network and a distributed version of PPO (i.e., actors collect massive amount of trajectories and the centralized learner updates the model parameters using PPO) is used to train the agents.12 Agents take $8 4 \times 8 4$ observation frames with proprioceptive features (e.g., robot joint positions and velocities) and output the mean and log of the standard deviation for each action dimension. The actions are then sampled from the Gaussian distribution parameterized by the output. Agents are trained on a single environment and tested on five unseen environments with various styles of table, floor, and block, as shown in Figure 14. For the Surreal robot manipulation experiment, the vanilla PPO agent is trained on 25 environments generated by changing the styles of tables and boxes. Specifically, we use {blue, gray, orange, white, purple $\}$ and {red, blue, green, yellow, cyan} for table and box, respectively.
+
+![](images/c8196d83f1dde6e9294c8e9735c6c59dda8c93bf9f52db3208a4fafa61c592a2.jpg)  
+Figure 13: (a) An illustration of network architectures for the Surreal robotics control experiment, and learning curves with (b) regularization and (c) data augmentation techniques. The solid line and shaded regions represent the mean and standard deviation, respectively, across three runs.
+
+# J EXTENSION TO DOMAINS WITH DIFFERENT DYNAMICS
+
+In this section, we consider an extension to the generalization on domains with different dynamics. Similar to dynamics randomization (Peng et al., 2018), one can expect that our idea can be useful for improving the dynamics generalization. To verify this, we conduct an experiment on CartPole and Hopper environments where an agent takes proprioceptive features (e.g., positions and velocities). The goal of CartPole is to prevent the pole from falling over, while that of Hopper is to make an onelegged robot hop forward as fast as possible, respectively. Similar to the randomization method we applied to visual inputs, we introduce a random layer between the input and the model. As a natural extension of the proposed method, we consider performing the convolution operation by multiplying a $d \times d$ diagonal matrix to $d$ -dimensional input states. For every training iteration, the elements of the matrix are sampled from the standard uniform distribution $U ( 0 . 8 , 1 . 2 )$ . One can note that this method can randomize the amplitude of input states while maintaining the intrinsic information (e.g., sign of inputs). Following Packer et al. (2018); Zhou et al. (2019), we measure the performance of the trained agents on unseen environments with a different set of dynamics parameters, such as mass, length, and force. Specifically, for CartPole experiments, similar to Packer et al. (2018), the policy and value functions are multi-layer perceptrons (MLPs) with two hidden layers of 64 units each and hyperbolic tangent activation and the Proximal Policy Optimization (PPO) (Schulman et al., 2017) method is used to train the agents. The parameters of the training environment are fixed at the default values in the implementations from Gym, while force, length, and mass of environments are sampled from $[ 1 , 5 ] \cup$ [15, 20], [0.05, 0.25] ∪ [0.75, 1.0], $[ 0 . 0 1 , 0 . { \overset { \cdot } { 0 } } 5 ] \cup [ 0 . 5 , 1 . 0 ]$ that the policy has never seen in any stage of training.13 For Hopper experiments, similar to Zhou et al. (2019), the policy is a MLP with two hidden layers of 32 units each and ReLU activation and value function is a linear model. The trust region policy optimization (TRPO) (Schulman et al., 2015) method is used to train the agents. The mass of the training environment is sampled from $\{ 1 . 0 , 2 . 0 , 3 . 0 , 4 . 0 , 5 . 0 \}$ , while it is sampled from $\{ 6 . 0 , 7 . 0 , 8 . 0 \}$ during testing.14 Figure 15 reports the mean and standard deviation across 3 runs. Our simple randomization improves the performance of the agents in unseen environments, while achieving performance comparable to seen environments. We believe that this evidences a wide applicability of our idea beyond visual changes.
+
+![](images/5ca179f5d42494adab1b56cc6a6972550fb09bcf4aaea1759591ce8eafe8a6ab.jpg)  
+Figure 14: Examples of seen and unseen environments in the Surreal robot manipulation.
+
+![](images/09c6ae2e2085699271ba114e185236c0c287af932634ef6a77629c72b9987e4e.jpg)  
+Figure 15: Performances of trained agents in seen and unseen environments under $( \mathrm { a } / \mathrm { b } )$ CartPole and $( \mathrm { c } / \mathrm { d } )$ Hopper. The solid/dashed lines and shaded regions represent the mean and standard deviation, respectively.
+
+![](images/8000019ef39900cf331b699a165d17eda56adf3dced4c6505052b515a57708f1.jpg)  
+Figure 16: (a) Modified CoinRun with good and bad coins. The performances on (b) seen and (c) unseen environments. The solid line and shaded regions represent the mean and standard deviation, respectively, across three runs. (d) Average success rates on large-scale CoinRun for varying the fraction of clean samples during training. Noe that $\alpha = 1$ corresponds to vanilla PPO agents.
+
+# K FAILURE CASE OF OUR METHODS
+
+In this section, we verify whether the proposed method can handle color (or texture)-conditioned RL tasks. One might expect that such RL tasks can be difficult for our methods to work because of the randomization. For example, our methods would fail if we consider an extreme seek-avoid object gathering setup, where the agent must learn to collect good objects and avoid bad objects which have the same shape but different color. However, we remark that our method would not always fail for such tasks if other environmental factors (e.g., the shape of objects in Collect Good Objects in DeepMind Lab (Beattie et al., 2016)) are available to distinguish them. To verify this, we consider a modified CoinRun environment where the agent must learn to collect good objects (e.g., gold coin) and avoid bad objects (e.g., silver coin). Similar to the small-scale CoinRun experiment, agents are trained to collect the goal object in a fixed map layout (see Figure 16(a)) and tested in unseen environments with only changing the style of the background. Figure 16(b) shows that our method can work well for such color-conditioned RL tasks because a trained agent can capture the other factors such as a location to perform this task. Besides, our method achieves a significant performance gain compared to vanilla PPO agent in unseen environments as shown in Figure 16(c).
+
+As another example, in color-matching tasks such as the keys doors puzzle in DeepMind Lab (Beattie et al., 2016), the agent must collect colored keys to open matching doors. Even though this task is color-conditioned, a policy trained with our method can perform well because the same colored objects will have the same color value even after randomization, i.e., our randomization method still maintains the structure of input observation. This evidences the wide applicability of our idea. We also remark that our method can handle more extreme corner cases by adjusting the fraction of clean samples during training. In summary, we believe that the proposed method covers a broad scope of generalization across low-level transformations in the observation space features.
+
+# L ABLATION STUDY FOR FRACTION OF CLEAN SAMPLES
+
+We investigate the effect of the fraction of clean samples. Figure 16(d) shows that the best unseen performance is achieved when the fraction of clean samples is 0.1 on large-scale CoinRun.
+
+# M TRAINING ALGORITHM
+
+# Algorithm 1 PPO + random networks, Actor-Critic Style
+
+<table><tr><td>for iteration= 1,2,·.· do Sample the parameterΦof random networks from prior distribution P() foractor=1,2,.,Ndo</td></tr><tr><td>Run policy π (alf (s; Φ) ; 0) in the given environment for T timesteps Compute advantage estimates</td></tr><tr><td>end for</td></tr><tr><td>Optimize Lrandom in equation (3) with respect to 0 end for</td></tr></table>
+
+![](images/85fbecd86f1482c7651cc1481e1d62791b60cb8e666813133b16645b480fa8bd.jpg)  
+Figure 17: Visualization of the hidden representation of trained agents optimized by (a) PPO, (b) $\mathrm { P P O } + \mathrm { L } 2$ , (c) $\mathrm { P P O + B N }$ , (d) $\mathrm { P P O } + \mathrm { D O }$ , (e) $\mathrm { P P O } + \mathrm { C O }$ , (f) $\mathrm { P P O } + \mathrm { G R }$ , (g) $\mathrm { P P O + I V } ,$ (h) $\mathrm { P P O } + \mathrm { C J }$ , and (I) $\mathrm { P P O + }$ ours using t-SNE. The point colors indicate the environments of the corresponding observations.

parse/train/LZDiWaC9CGL/LZDiWaC9CGL.md

@@ -0,0 +1,341 @@
+# Multiwavelet-based Operator Learning for Differential Equations
+
+Gaurav Gupta, Xiongye Xiao, Paul Bogdan Ming Hsieh Department of Electrical and Computer Engineering University of Southern California, Los Angeles, CA 90089 {ggaurav, xiongyex, pbogdan}@usc.edu
+
+# Abstract
+
+The solution of a partial differential equation can be obtained by computing the inverse operator map between the input and the solution space. Towards this end, we introduce a multiwavelet-based neural operator learning scheme that compresses the associated operator’s kernel using fine-grained wavelets. By explicitly embedding the inverse multiwavelet filters, we learn the projection of the kernel onto fixed multiwavelet polynomial bases. The projected kernel is trained at multiple scales derived from using repeated computation of multiwavelet transform. This allows learning the complex dependencies at various scales and results in a resolution-independent scheme. Compare to the prior works, we exploit the fundamental properties of the operator’s kernel which enable numerically efficient representation. We perform experiments on the Korteweg-de Vries (KdV) equation, Burgers’ equation, Darcy Flow, and Navier-Stokes equation. Compared with the existing neural operator approaches, our model shows significantly higher accuracy and achieves state-of-the-art in a range of datasets. For the time-varying equations, the proposed method exhibits a $( 2 X - 1 0 X )$ improvement (0.0018 (0.0033) relative $L 2$ error for Burgers’ (KdV) equation). By learning the mappings between function spaces, the proposed method has the ability to find the solution of a high-resolution input after learning from lower-resolution data.
+
+# 1 Introduction
+
+Many natural and human-built systems (e.g., aerospace, complex fluids, neuro-glia information processing) exhibit complex dynamics characterized by partial differential equations (PDEs) [52, 60]. For example, the design of wings and airplanes robust to turbulence, requires to learn complex PDEs. Along the same lines, complex fluids (gels, emulsions) are multiphasic materials characterized by a macroscopic behavior [55] modeled by non-linear PDEs. Understanding their variations in viscosity as a function of the shear rate is critical for many engineering projects. Moreover, modeling the dynamics of continuous and discrete cyber and physical processes in complex cyber-physical systems can be achieved through PDEs [68].
+
+Recent efforts on learning PDEs (i.e., mappings between infinite-dimensional spaces of functions), from trajectories of variables, focused on developing machine learning and in particular deep neural networks (NNs) techniques. Towards this end, a stream of work aims at parameterizing the solution map as deep NNs [2, 13, 33, 40, 71]. One issue, however, is that the NNs are tied to a specific resolution during training, and therefore, may not generalize well to other resolutions, thus, requiring retraining (and possible modifications of the model) for every set of discretizations. In parallel, another stream of work focuses on constructing the PDE solution function as a NN architecture [31, 42, 57, 65]. This approach, however, is designed to work with one instance of a PDE and, therefore, upon changing the coefficients associated with the PDE, the model has to be re-trained.
+
+Additionally, the approach is not a complete data-dependent one, and hence, cannot be made oblivious to the knowledge of the underlying PDE structure. Finally, the closest stream of work to the problem we investigate is represented by the “Neural Operators" [14, 47, 48, 49, 56]. Being a complete data-driven approach, the neural operators method aims at learning the operator map without having knowledge of the underlying PDEs. The neural operators have also demonstrated the capability of discretization-independence. Obtaining the data for learning the operator map could be prohibitively expensive or time consuming (e.g., aircraft performance to different initial conditions). To be able to better solve the problem of learning the PDE operators from scarce and noisy data, we would ideally explore fundamental properties of the operators that have implications in data-efficient representation.
+
+Our intuition is to transform the problem of learning a PDE to a domain where a compact representation of the operator exists. With a mild assumption regarding the smoothness of the operator’s kernel, except finitely many singularities, the multiwavelets [5], with their vanishing moments property, sparsify the kernel in their projection with respect to (w.r.t.) a measure. Therefore, learning an operator kernel in the multiwavelet domain is feasible and data efficient. The wavelets have a rich history in signal processing [24, 25], and are popular in audio, image compression [8, 61]. For multiwavelets, the orthogonal polynomial (OP) w.r.t. a measure emerges as a natural basis for the multiwavelet subspace, and an appropriate scale / shift provides a sequence of subspaces which captures the locality at various resolutions. We generalize and exploit the multiwavelets concept to work with arbitrary measures which opens-up new possibilities to design a series of models for the operator learning from complex data streams.
+
+We incorporate the multiwavelet filters derived using a variety of the OP basis into our operator learning model, and show that the proposed architecture outperforms the existing neural operators. Our main contributions are as follows: (i) Based on some fundamental properties of the integral operator’s kernel, we develop a multiwavelet-based model which learns the operator map efficiently. (ii) For the 1-D dataset of non-linear Korteweg-de Vries and Burgers equations, we observe an order of magnitude improvement in the relative $L 2$ error (Section 3.1, 3.3). (iii) We demonstrate that the proposed model is in validation with the theoretical properties of the pseudo-differential operator (Section 3.2). (iv) We show how the proposed multiwavelet-based model is robust towards the fluctuation strength of the input signal (Section 3.1). (v) Next, we demonstrate the applicability on higher dimensions of 2-D Darcy flow equation (Section 3.4), and finally show that the proposed approach can learn at lower resolutions and generalize to higher resolutions. The code for reproducing the experiments is available at: https://github.com/gaurav71531/mwt-operator.
+
+# 2 Operator Learning using Multiwavelet Transform
+
+We start by defining the problem of operator learning in Section 2.1. Section 2.2 defines the multiwavelet transform for the proposed operator learning problem and derives the necessary transformation operations across different scales. Section 2.3 outlines the proposed operator learning model. Finally, Section 2.4 lists some of the useful properties of the operators which leads to an efficient implementation of multiwavelet-based models.
+
+# 2.1 Problem Setup
+
+Given two functions $a ( x )$ and $u ( x )$ with $x \in D$ , the operator is a map $T$ such that $T a = u$ . Formally, let $\mathcal { A }$ and $\mathcal { U }$ be two Sobolev spaces $\mathcal { H } ^ { s , p }$ $( s > 0 , p \ge 1 )$ ), then the operator $T$ is such that $T : { \mathcal { A } }  { \mathcal { U } }$ . The Sobolev spaces are particularly useful in the analysis of partial differential equations (PDEs), and we restrict our attention to $s > 0$ and $p = 2$ . Note that, for $s = 0$ , the $\mathcal { H } ^ { 0 , p }$ coincides with $L ^ { p }$ , and, $f \in \mathcal { H } ^ { 0 , p }$ does not necessarily have derivatives in $L ^ { p }$ . We choose $p = 2$ in order to be able to define projections with respect to (w.r.t.) measures $\mu$ in a Hilbert space structure.
+
+We take the operator $T$ as an integral operator with the kernel $K : D \times D  L ^ { 2 }$ such that
+
+$$
+T a ( x ) = \int _ { D } K ( x , y ) a ( y ) d y .
+$$
+
+For the case of inhomogeneous linear PDEs, $\mathcal { L } u = f$ , with $f$ being the forcing function, $\mathcal { L }$ is the differential operator, and the associated kernel is commonly termed as Green function. In our case, we do not put the restriction of linearity on the operator. From eq. (1), it is apparent that learning the complete kernel $K ( . , . )$ would essentially solve the operator map problem, but it is not necessarily a numerically feasible solution. Indeed, a better approach would be to exploit possible useful properties (see Section 2.4) such that a compact representation of the kernel can be made. For an efficient representation of the operator kernel, we need an appropriate subspace (or sequence of subspaces), and projection tools to map to such spaces.
+
+Norm with respect to measures: Projecting a given function onto a fixed basis would require a measure dependent distance. For two functions $f$ and $g$ , we take the inner product w.r.t measure $\mu$ as $\begin{array} { r } { { \langle f , g \rangle _ { \mu } = \int f ( x ) g ( x ) d \mu ( x ) } } \end{array}$ , and the associated norm as $\vert \vert f \vert \vert _ { \mu } = \langle f , f \rangle _ { \mu } ^ { 1 / 2 }$ . We now discuss the next ingredient, which refers to the subspaces required to project the kernel.
+
+# 2.2 Multiwavelet Transform
+
+In this section, we briefly overview the concept of multiwavelets [4] and extend it to work with nonuniform measures at each scale. The multiwavelet transform synergizes the advantages of orthogonal polynomials (OPs) as well as the wavelets concepts, both of which have a rich history in the signal processing. The properties of wavelet bases like $( i )$ vanishing moments, and $( i i )$ orthogonality can effectively be used to create a system of coordinates in which a wide class of operators (see Section 2.4) have a nice representation. Multiwavelets go few steps further, and provide a fine-grained representation using OPs, but also act as a basis on a finite interval. For the rest of this section, we restrict our attention to the interval $[ 0 , 1 ]$ ; however, the transformation to any finite interval $[ a , b ]$ could be straightforwardly obtained by an appropriate shift and scale.
+
+Multi Resolution Analysis: We begin by defining the space of piecewise polynomial functions, for $k \in \mathbb N$ and $n \in \mathbb { Z } ^ { + } \cup \{ 0 \}$ as, $\begin{array} { r } { \mathbf { V } _ { n } ^ { k } = \bigcup _ { l = 0 } ^ { 2 ^ { n } - 1 } \{ f | \deg ( f ) < k } \end{array}$ for $x \in ( 2 ^ { - n } l , 2 ^ { - n } ( l + 1 ) ) \land$ 0, elsewhere $\}$ . Clearly, $\dim ( \mathbf { V } _ { n } ^ { k } ) \ : = \ : 2 ^ { n } k$ , and for subsequent $n$ , each subspace is contained in another as shown by the following relation:
+
+$$
+\mathbf { V } _ { 0 } ^ { k } \subset \mathbf { V } _ { 1 } ^ { k } \ldots \subset \mathbf { V } _ { n - 1 } ^ { k } \subset \mathbf { V } _ { n } ^ { k } \subset \ldots .
+$$
+
+Similarly, we define the sequence of measures $\mu _ { 0 } , \mu _ { 1 } , \ldots$ such that $f \in \mathbf { V } _ { n } ^ { k }$ is measurable w.r.t. $\mu _ { n }$ and the norm of $f$ is taken as $| | f | | = \langle f , f \rangle _ { \mu _ { n } } ^ { 1 / 2 }$ . Next, since $\mathbf { V } _ { n - 1 } ^ { k } \subset \mathbf { V } _ { n } ^ { k }$ , we define the multiwavelet subspace as $\mathbf { W } _ { n } ^ { k }$ for $n \in \mathbb { Z } ^ { + } \cup \{ 0 \}$ , such that
+
+$$
+\mathbf { V } _ { n + 1 } ^ { k } = \mathbf { V } _ { n } ^ { k } \bigoplus \mathbf { W } _ { n } ^ { k } , \quad \mathbf { V } _ { n } ^ { k } \bot \mathbf { W } _ { n } ^ { k } .
+$$
+
+For a given OP basis for $\mathbf { V } _ { 0 } ^ { k }$ as $\phi _ { 0 } , \phi _ { 1 } , \ldots , \phi _ { k - 1 }$ w.r.t. measure $\mu _ { 0 }$ , a basis of the subsequent spaces $\mathbf { V } _ { n } ^ { k } , n > 1$ can be obtained by shift and scale (hence the name, multi-scale) operations of the original basis as follows:
+
+$$
+\phi _ { j l } ^ { n } ( x ) = 2 ^ { n / 2 } \phi _ { j } ( 2 ^ { n } x - l ) , \quad j = 0 , 1 , \ldots , k - 1 , \quad l = 0 , 1 , \ldots , 2 ^ { n } - 1 , \mathrm { w . r . t . } \quad \mu _ { n } ,
+$$
+
+where, $\mu _ { n }$ is obtained as the collections of shift and scale of $\mu _ { 0 }$ , accordingly.
+
+Multiwavelets: For the multiwavelet subspace $\mathbf { W } _ { 0 } ^ { k }$ , the orthonormal basis (of piecewise polynomials) are taken as $\psi _ { 0 } , \psi _ { 1 } , \dots , \psi _ { k - 1 }$ such that $\langle \psi _ { i } , \psi _ { j } \rangle _ { \mu _ { 0 } } = 0$ for $i \neq j$ and 1, otherwise. From eq. (3), $\mathbf { V } _ { n } ^ { k } \perp \mathbf { W } _ { n } ^ { k }$ , and since $\mathbf { V } _ { n } ^ { k }$ spans the polynomials of degree at most $k$ , therefore, we conclude that
+
+$$
+\int _ { 0 } ^ { 1 } x ^ { i } \psi _ { j } ( x ) d \mu _ { 0 } ( x ) = 0 , \quad \forall 0 \leq j , i < k .
+$$
+
+Similarly to eq. (4), a basis for multiwavelet subspace $\mathbf { W } _ { n } ^ { k }$ are obtained by shift and scale of $\psi _ { i }$ as $\psi _ { j l } ^ { n } ( x ) = 2 ^ { n / 2 } \psi _ { j } ( 2 ^ { n } x - l )$ and $\psi _ { j l } ^ { n }$ are orthonormal w.r.t. measure $\mu _ { n }$ , i.e. $\langle \psi _ { j l } ^ { n } , \psi _ { j ^ { \prime } l ^ { \prime } } ^ { n } \rangle _ { \mu _ { n } } = 1$ if $j = j ^ { \prime } , l = l ^ { \prime }$ , and 0 otherwise. Therefore, for a given OP basis for $\mathbf { V } _ { 0 } ^ { k }$ (for example, Legendre, Chebyshev polynomials), we only require to compute $\psi _ { i }$ , and a complete basis set at all the scales can be obtained using scale/shift of $\phi _ { i } , \psi _ { i }$ .
+
+Note: Since $\mathbf { V } _ { 1 } ^ { k } = \mathbf { V } _ { 0 } ^ { k } \oplus \mathbf { W } _ { 0 } ^ { k }$ from eq. (3), therefore, for a given basis $\phi _ { i }$ of $\mathbf { V } _ { 0 } ^ { k }$ w.r.t. measure $\mu _ { 0 }$ and $\phi _ { j l } ^ { n }$ as a basis for $\mathbf { V } _ { 1 } ^ { k }$ w.r.t. $\mu _ { 1 }$ , a set of basis $\psi _ { i }$ can be obtained by applying Gram-Schmidt
+
+![](images/077eaacf6a88d1416897b372fd0c11cc0b20d5dcce8fd8b7b7b79f223c5dffb2.jpg)  
+Figure 1: Multiwavelet representation of the Kernel. (i) Given kernel $K ( x , y )$ of an integral operator $T$ , (ii) the bases with different measures $( \mu _ { 0 } , \mu _ { 1 } )$ at two different scales (coars ${ \mathrm { : = } } 0$ , fine $^ { = 1 }$ ) projects the kernel into 3 components $A _ { i } , B _ { i } , C _ { i }$ . (iii) The decomposition yields a sparse structure, and the entries with absolute magnitude values exceeding $1 e ^ { - 8 }$ are shown in black. Given projections at any scale, the finer / coarser scale projections can be obtained by reconstruction $/$ decomposition using a fixed multiwavelet filters $H ^ { ( i ) }$ and $\mathbf { \bar { \cal G } } ^ { ( i ) } , i = 0 , 1$ .
+
+Orthogonalization using appropriate measures. We refer the reader to supplementary materials for the detailed procedure.
+
+Note: Since $\mathbf { V } _ { 0 } ^ { k }$ and $\mathbf { W } _ { 0 } ^ { k }$ lives in $\mathbf { V } _ { 1 } ^ { k }$ , therefore, $\phi _ { i } , \psi _ { i }$ can be written as a linear combination of the basis of $V _ { 1 } ^ { k }$ . We term these linear coefficients as multiwavelet decomposition filters $( H ^ { ( 0 ) } , H ^ { ( 1 ) } , G ^ { ( 0 ) } , G ^ { ( 1 ) } )$ , since they are transforming a fine $n = 1$ to coarse scale $n = 0$ . A uniform measure $\left( \mu _ { 0 } \right)$ version is discussed in [4], and we extend it to any arbitrary measure by including the correction terms $\Sigma ^ { ( 0 ) }$ and $\Sigma ^ { ( 1 ) }$ . We refer to supplementary materials for the complete details. The capability of using the non-uniform measures enables us to apply the same approach to any OP basis with finite domain, for example, Chebyshev, Gegenbauer, etc.
+
+For a given $[ \langle f , \phi _ { i l } ^ { n } \rangle _ { \mu _ { n } } ] _ { i = 0 } ^ { k - 1 }$ $f ( x )$ , ${ \bf d } _ { l } ^ { n } = [ \langle f , \psi _ { i l } ^ { n } \rangle _ { \mu _ { n } } ] _ { i = 0 } ^ { k - 1 }$ , the multiscale, multiwavelet coefficients at the scale , respectively, w.r.t. measure $\mu _ { n }$ with $n$ $\mathbf { s } _ { l } ^ { n } , \mathbf { d } _ { l } ^ { n } \in \mathbb { R } ^ { k \times 2 ^ { n } }$ are defined as $\mathbf { s } _ { l } ^ { n } \mathbf { \Psi } =$ l . The decomposition / reconstruction across scales is written as
+
+$$
+\begin{array} { r l } { \mathbf { s } _ { l } ^ { n } = H ^ { ( 0 ) } \mathbf { s } _ { 2 l } ^ { n + 1 } + H ^ { ( 1 ) } \mathbf { s } _ { 2 l + 1 } ^ { n + 1 } , \quad } & { ( 6 ) \qquad \mathbf { s } _ { 2 l } ^ { n + 1 } = \Sigma ^ { ( 0 ) } ( H ^ { ( 0 ) T } \mathbf { s } _ { l } ^ { n } + G ^ { ( 0 ) T } \mathbf { d } _ { l } ^ { n } ) , } \\ { \mathbf { d } _ { l } ^ { n } = G ^ { ( 0 ) } \mathbf { s } _ { 2 l } ^ { n + 1 } + H ^ { ( 1 ) } \mathbf { s } _ { 2 l + 1 } ^ { n + 1 } . \quad } & { ( 7 ) \qquad \mathbf { s } _ { 2 l + 1 } ^ { n + 1 } = \Sigma ^ { ( 1 ) } ( H ^ { ( 1 ) T } \mathbf { s } _ { l } ^ { n } + G ^ { ( 1 ) T } \mathbf { d } _ { l } ^ { n } ) . } \end{array}
+$$
+
+The wavelet (and also multiwavelet) transformation can be straightforwardly extended to multiple dimensions using tensor product of the bases. For our purpose, a function $\dot { \boldsymbol { f } } \in \mathbb { R } ^ { d }$ has multiscale, multiwavelet coefficients $\bar { \mathbf { s } } _ { l } ^ { n } , \mathbf { d } _ { l } ^ { n } \in \mathbb { R } ^ { k \times \ldots \times k \times 2 ^ { n } }$ which are also recursively obtained by replacing the filters in eq. (6)-(7) with their Kronecker product, specifically, $H ^ { ( 0 ) }$ with $H ^ { ( 0 ) } \otimes H ^ { ( 0 ) } \otimes . . . H ^ { ( 0 ) }$ , where $\otimes$ is the Kronecker product repeated $d$ times. For eq. (8)-(9) $H ^ { ( 0 ) } \Sigma ^ { ( 0 ) }$ (and similarly others) are replaced with their $d$ -times Kronecker product.
+
+Non-Standard Form: The multiwavelet representation of the operator kernel $K ( x , y )$ can be obtained by an appropriate tensor product of the multiscale and multiwavelet basis. One issue, however, in this approach, is that the basis at various scales are coupled because of the tensor product. To untangle the basis at various scales, we use a trick as proposed in [11] called the non-standard wavelet representation. The extra mathematical price paid for the non-standard representation, actually serves as a ground for reducing the proposed model complexity (see Section 2.3), thus, providing data efficiency. For the operator under consideration $T$ with integral kernel $K ( x , y )$ , let us denote $T _ { n }$ as the projection of $T$ on $V _ { n } ^ { k }$ , which essentially is obtained by projecting the kernel $K$ onto basis $\phi _ { j l } ^ { n }$ w.r.t. measure $\mu _ { n }$ . If $P _ { n }$ is the projection operator such that $\begin{array} { r } { P _ { n } f = \sum _ { j , l } \langle f , \phi _ { j l } ^ { n } \rangle _ { \mu _ { n } } \phi _ { j l } ^ { n } } \end{array}$ , then $\check { T _ { n } } = P _ { n } T P _ { n }$ . Using telescopic sum, $T _ { n }$ is expanded as
+
+![](images/0921619ef9d37acae33bddd11b5deaf1404fb4733447777da7368c77060d2447.jpg)  
+Figure 2: MWT model architecture. (Left) Decomposition cell using 4 neural networks (NNs) $A , B$ and $C$ , and $T$ (for the coarsest scale $L$ ) performs multiwavelet decomposition from scale $n + 1$ to $_ n$ . (Right) Reconstruction module using pre-defined filters $H ^ { ( i ) } , G ^ { ( i ) }$ performs inverse multiwavelet transform from scale $n - 1$ to $n$ .
+
+$$
+T _ { n } = \sum _ { i = L + 1 } ^ { n } ( Q _ { i } T Q _ { i } + Q _ { i } T P _ { i - 1 } + P _ { i - 1 } T Q _ { i } ) + P _ { L } T P _ { L } ,
+$$
+
+where, $Q _ { i } = P _ { i } - P _ { i - 1 }$ and $L$ is the coarsest scale under consideration $( L \geq 0 )$ . From eq. (3), it is apparent that $Q _ { i }$ is the multiwavelet operator. Next, we denote $A _ { i } = Q _ { i } { \cal T } Q _ { i } , B _ { i } = Q _ { i } { \cal T } P _ { i - 1 } , C _ { i } =$ $P _ { i - 1 } T Q _ { i }$ , and $\bar { T } = P _ { L } T P _ { L }$ . In Figure 1, we show the non-standard multiwavelet transform for a given kernel $K ( x , y )$ . The transformation has a sparse banded structure due to smoothness property of the kernel (see Section 2.4). For the operator $T$ such that $T a = u$ , the map under multiwavelet domain is written as
+
+$$
+U _ { d l } ^ { n } = A _ { n } d _ { l } ^ { n } + B _ { n } s _ { l } ^ { n } , \qquad U _ { \hat { s } l } ^ { n } = C _ { n } d _ { l } ^ { n } , \qquad U _ { s l } ^ { L } = \bar { T } s _ { l } ^ { L } ,
+$$
+
+where, $( U _ { s l } ^ { n } , U _ { d l } ^ { n } ) / ( s _ { l } ^ { n } , d _ { l } ^ { n } )$ are the multiscale, multiwavelet coefficients of $u / a$ , respectively, and $L$ is the coarsest scale under consideration. With these mathematical concepts, we now proceed to define our multiwavelet-based operator learning model in the Section 2.3.
+
+# 2.3 Multiwavelet-based Model
+
+Based on the discussion in Section 2.2, we propose a multiwavelet-based model (MWT) as shown in Figure 2. For a given input/output as $a / u$ , the goal of the MWT model is to map the multiwavelettransform of the input $( \bar { s } _ { l } ^ { N } )$ to output $( U _ { s l } ^ { N } )$ at the finest scale $N$ . The model consists of two parts: (i) Decomposition $( d e c )$ , and $( i i )$ Reconstruction (rec). The dec acts as a recurrent network, and at each iteration the input is $s ^ { n + 1 }$ . Using (6)-(7), the input is used to obtain multiscale and multiwavelet coefficients at a coarser level $s ^ { n }$ and $d ^ { n }$ , respectively. Next, to compute the multiscale/multiwavelet coefficients of the output $u$ , we approximate the non-standard kernel decomposition from (11) using four neural networks (NNs) $A , B , C$ and $\bar { T }$ such that $U _ { d l } ^ { n } \approx A _ { \theta _ { A } } ( d _ { l } ^ { n } ) \stackrel { - } { + } B _ { \theta _ { B } } ( s _ { l } ^ { n } ) , U _ { \hat { s } l } ^ { n } \approx$ $C _ { \theta _ { C } } ( d _ { l } ^ { n } ) , \forall 0 \leq n < L$ , and $U _ { s l } ^ { L } \approx \bar { T } _ { \theta _ { \bar { T } } } ( s _ { l } ^ { L } )$ . This is a ladder-down approach, and the dec part performs the decimation of signal (factor $\bar { 1 } / 2$ ), running for a maximum of $L$ cycles, $L < \log _ { 2 } ( M )$ for a given input sequence of size $M$ . Finally, the rec module collects the constituent terms $U _ { s l } ^ { n } , U _ { \hat { s } l } ^ { n } , U _ { d l } ^ { n }$ (obtained using the dec module) and performs a ladder-up operation to compute the multiscale coefficients of the output at a finer scale $n + 1$ using (8)-(9). The iterations continue until the finest scale $N$ is obtained for the output.
+
+At each iteration, the filters in dec module downsample the input, but compared to popular techniques (e.g., maxpool), the input is only transformed to a coarser multiscale/multiwavelet space. By virtue of its design, since the non-standard wavelet representation does not have inter-scale interactions, it basically allows us to reuse the same kernel NNs $A , B , C$ at different scales. A follow-up advantage of this approach is that the model is resolution independent, since the recurrent structure of dec is input invariant, and for a different input size $M$ , only the number of iterations would possibly change for a maximum of $\log _ { 2 } M$ . The reuse of $A , B , C$ by re-training at various scales also enable us to learn an expressive model with fewer parameters $( \theta _ { A } , \theta _ { B } , \theta _ { C } , \theta _ { \bar { T } } )$ . We see in Section 3, that even a single-layered CNN for $A , B , C$ is sufficient for learning the operator.
+
+The dec / rec module uses the filter matrices which are fixed beforehand, therefore, this part does not require any training. The model does not work for any arbitrary choice of fixed matrices $H , G$ . We show in Section 3.4 that for randomly selected matrices, the model does not learn, which validates that careful construction of filter matrices is necessary.
+
+# 2.4 Operators Properties
+
+This section outlines definition of the integral kernels that are typically useful in an efficient compression of the operators through multiwavelets. We then discuss a fundamental property of the pseudo-differential operator.
+
+Definition 1 ([54]). Calderón-Zygmund Operator. The integral operators that have kernel $K ( x , y )$ which is smooth away from the diagonal, and satisfy the following.
+
+$$
+\begin{array} { c } { \displaystyle { | K ( x , y ) | \le \frac { 1 } { | x - y | } , } } \\ { \displaystyle { | \partial _ { x } ^ { M } K ( x , y ) | + | \partial _ { y } ^ { M } K ( x , y ) | \le \frac { C _ { 0 } } { | x - y | ^ { M + 1 } } . } } \end{array}
+$$
+
+The smooth functions with decaying derivatives are gold to the multiwavelet transform. Note that, smoothness implies Taylor series expansion, and the multiwavelet transform with sufficiently large $k$ zeroes out the initial $k$ terms of the expansion due to vanishing moments property (5). This is how multiwavelet sparsifies the kernel (see Figure 1 where $K ( x , y )$ is smooth). Although, the definition of Calderón-Zygmund is simple (singularities only at the diagonal), but the multiwavelets are capable to compresses the kernel as long as the number of singularities are finite.
+
+The next property, from [19], points out that with input/output being single-dimensional functions, for any pseudo-differential operator (with smooth coefficients), the singularity at the diagonal is also well-characterized.
+
+Property 1. Smoothness of Pseudo-Differential Operator. For the integral kernel $K ( x , y )$ of $a$ pseudo-differential operator, $K ( x , y ) \in C ^ { \infty } \forall x \neq y$ , and for $x = y$ , $K ( x , y ) \in C ^ { T - 1 }$ , where $T + 1$ is the highest derivative order in the given pseudo-differential equation.
+
+The property 1 implies that, for the class of pseudo-differential operator, and any set of basis with the initial $J$ vanishing moments, the projection of kernel onto such bases will have the diagonal dominating the non-diagonal entries, exponentially, if $J > T - 1$ [19]. For the case of multiwavelet basis with $k$ OPs, $J = k$ (from eq. (5)). Therefore, $k > T - 1$ sparsifies the kernel projection onto multiwavelets, for a fixed number of bits precision $\epsilon$ . We see the implication of the Property 1 on our proposed model in the Section 3.2.
+
+# 3 Empirical Evaluation
+
+In this section, we evaluate the multiwavelet-based model (MWT) on several PDE datasets. We show that the proposed MWT model not only exhibits orders of magnitude higher accuracy when compared against the state-of-the-art (Sota) approaches but also works consistently well under different input conditions without parameter tuning. From a numerical perspective, we take the data as point-wise evaluations of the input and output functions. Specifically, we have the dataset $( a _ { i } , u _ { i } )$ with $a _ { i } = a ( x _ { i } ) , u _ { i } = u ( x _ { i } )$ for $x _ { 1 } , x _ { 2 } , \dotsc , x _ { N } \in D$ , where $x _ { i }$ are $M$ -point discretization of the domain $D$ . Unless stated otherwise, the training set is of size 1000 while test is of size 200.
+
+Model architectures: Unless otherwise stated, the NNs $A , B$ and $C$ in the proposed model (Figure 2) are chosen as a single-layered CNNs following a linear layer, while $\bar { T }$ is taken as single $k \times k$ linear layer. We choose $k = 4$ in all our experiments, and the OP basis as Legendre (Leg), Chebyshev (Chb) with uniform, non-uniform measure $\mu _ { 0 }$ , respectively. The model in Figure 2 is treated as single layer, and for 1D equations, we cascade 2 multiwavelet layers, while for 2D dataset, we use a total 4 layers with $R e L U$ non-linearity.
+
+<table><tr><td>Networks</td><td>s =64</td><td>s=128</td><td>s = 256</td><td>s = 512</td><td>s = 1024</td></tr><tr><td>MWT Leg MWT Chb</td><td>0.00338 0.00715</td><td>0.00375 0.00712</td><td>0.00418 0.00604</td><td>0.00393 0.00769</td><td>0.00389</td></tr><tr><td>FNO</td><td>0.0125</td><td>0.0124</td><td>0.0125</td><td>0.0122</td><td>0.00675 0.0126</td></tr><tr><td>MGNO</td><td>0.1296</td><td>0.1515</td><td>0.1355</td><td>0.1345</td><td>0.1363</td></tr><tr><td>LNO</td><td>0.0429</td><td>0.0557</td><td>0.0414</td><td>0.0425</td><td>0.0447</td></tr><tr><td>GNO</td><td>0.0789</td><td>0.0760</td><td>0.0695</td><td>0.0699</td><td>0.0721</td></tr></table>
+
+Table 1: Korteweg-de Vries (KdV) equation benchmarks for different input resolution s. Top: Our methods. Bottom: previous works of Neural operator.
+
+![](images/b0004050902d1d4696836111b6830f046446812dc2ba692989a82d801aa436b5.jpg)  
+Figure 3: The output of the KdV equation. (Left) An input $u _ { 0 } ( x )$ with $\lambda = 0 . 0 2$ . (Right) The predicted output of the MWT Leg model learning the high fluctuations.
+
+From a mathematical viewpoint, the dec and rec modules in Figure 2 transform only the multiscale and multiwavelet coefficients. However, the input and output to the model are point-wise function samples, i.e., $( a _ { i } , u _ { i } )$ . A remedy around this is to take the data sequence, and construct hypothetical functions $\begin{array} { r } { f _ { a } = \sum _ { i = 1 } ^ { N } a _ { i } \phi _ { j i } ^ { n } } \end{array}$ and $\begin{array} { r } { f _ { u } = \sum _ { i = 1 } ^ { N } u _ { i } \phi _ { j i } ^ { n } } \end{array}$ . Clearly, $f _ { a } , f _ { u }$ lives in $V _ { n } ^ { k }$ with $n = \log _ { 2 } N$ . Now the model can be used with $s ^ { ( n ) } = a _ { i }$ and $U _ { s } ^ { ( n ) } = u _ { i }$ . Note that $f _ { a } , f _ { u }$ are not explicitly used, but only a matter of convention.
+
+Benchmark models: We compare our MWT model using two different OP basis (Leg, Chb) with the most recent successful neural operators. Specifically, we consider the graph neural operator (GNO) [48], the multipole graph neural operator (MGNO) [49], the LNO which makes a low-rank $( r )$ representation of the operator kernel $K ( x , y )$ (also similar to unstacked DeepONet [50]), and the Fourier neural operator (FNO ) [47]. We experiment on three competent datasets setup by the work of FNO (Burgers’ equation (1-D), Darcy Flow (2-D), and Navier-Stokes equation (time-varying 2-D)). In addition, we also experiment with Korteweg-de Vries equation (1-D). For the 1-D cases, a modified FNO with careful parameter selection and removal of Batch-normalization layers results in a better performance compared with the original FNO, and we use it in our experiments. The MWT model demonstrates the highest accuracy in all the experiments. The MWT model also shows the ability to learn the function mapping through lower-resolution data, and able to generalize to higher resolutions.
+
+All the models (including ours) are trained for a total of 500 epochs using Adam optimizer with an initial learning rate (LR) of 0.001. The LR decays after every 100 epochs with a factor of $\gamma = 0 . 5$ The loss function is taken as relative $L 2$ error [47]. All of the experiments are performed on a single Nvidia V100 32 GB GPU, and the results are averaged over a total of 3 seeds.
+
+# 3.1 Korteweg-de Vries (KdV) Equation
+
+The Korteweg-de Vries (KdV) equation was first proposed by Boussinesq [16] and rediscovered by Korteweg and de Vries [23]. KdV is a 1-D non-linear PDE commonly used to describe the non-linear shallow water waves. For a given field $u ( x , t )$ , the dynamics takes the following form:
+
+$$
+\begin{array} { c } { \displaystyle { \frac { \partial u } { \partial t } = - 0 . 5 u \frac { \partial u } { \partial x } - \frac { \partial ^ { 3 } u } { \partial x ^ { 3 } } , x \in ( 0 , 1 ) , t \in ( 0 , 1 ] } } \\ { \displaystyle { u _ { 0 } ( x ) = u ( x , t = 0 ) } } \end{array}
+$$
+
+The task for the neural operator is to learn the mapping of the initial condition $u _ { 0 } ( x )$ to the solutions $u ( x , t = 1 )$ . We generate the initial condition in Gaussian random fields according to $u _ { 0 } \sim$ $\dot { \mathcal { N } } ( 0 , 7 ^ { 4 } ( - \Delta + 7 ^ { 2 } \bar { I _ { ) } } ^ { - 2 . 5 } )$ with periodic boundary conditions. The equation is numerically solved using chebfun package [27] with a resolution $2 ^ { 1 0 }$ , and datasets with lower resolutions are obtained by sub-sampling the highest resolution data set.
+
+Varying resolution: The experimental results of the KdV equation for different input resolutions $s$ are shown in Table1. We see that, compared to any of the benchmarks, our proposed MWT Leg exhibits the lowest relative error and is lowest nearly by an order of magnitude. Even in the case of the resolution of 64, the relative error is low, which means that a sparse data set with a coarse resolution of 64 is sufficient for the neural operator to learn the function mapping between infinite-dimensional spaces.
+
+Varying fluctuations: We now vary the smoothness of the input function $u _ { 0 } ( x , 0 )$ by controlling the parameter $\lambda$ , where low values of $\lambda$ imply more frequent fluctuations and $\lambda  0$ reaches the Brownian motion limit [30]. To isolate the importance of incorporating the multiwavelet transformation, we use the same convolution operation as in FNO, i.e., Fourier transform-based convolution with different modes $k _ { m }$ (only single-layer) for $A , B , C$ . We see in Figure 4 that MWT model consistently outperforms the recent baselines for all the values of $\lambda$ . A sample input/output from test set is shown in the Figure 3. The FNO model with higher values of $k _ { m }$ has better performance due to more Fourier bases for representing the high-frequency signal, while MWT does better even with low modes in its $A , B , C$ CNNs, highlighting the importance of using wavelet-based filters in the signal processing.
+
+![](images/66c0995dded710f31f0f2976672ba887d6cdc8243cfded66fa80fa7a23a8cfa4.jpg)  
+Figure 4: Comparing MWT by varying the degree of fluctuations $\lambda$ in the input with resolution $s =$ 1024. For each convolution, we fix the number of Fourier bases as $k _ { m }$ . For FNO, the width is 64.
+
+# 3.2 Theoretical Properties Validation
+
+We test the ability of the proposed MWT model to capture the theoretical properties of the pseudodifferential operator in this Section. Towards that, we consider the Euler-Bernoulli equation [62] that models the vertical displacement of a finite length beam over time. A Fourier transform version of the beam equation with the constraint of both ends being clamped is as follows
+
+$$
+\begin{array} { c } { { \displaystyle { \frac { \partial ^ { 4 } u } { \partial x ^ { 4 } } } - \omega ^ { 2 } u = f ( x ) , \quad \displaystyle { \frac { \partial u } { \partial x } } \Big \vert _ { x = 0 } = 0 } } \\ { { u ( 0 ) = u ( 1 ) = 0 , } } \end{array}
+$$
+
+where $u ( x )$ is the Fourier transform of the time-varying beam displacement, $\omega$ is the frequency, $f ( x )$ is the applied force. The Euler-Bernoulli is a pseudo-differential equation with the maximum derivative order $T + 1 = 4$ . We take the task of learning the map from $f$ to $u$ . In Figure 5, we see that for $k \geq 3$ , the models relative error across epochs is similar, however, they are different for $k < 3$ , which is in accordance with the Property 1. For $k < 3$ , the multiwavelets will not be able to annihilate the diagonal of the kernel which is $C ^ { T - 1 }$ , hence, sparsification cannot occur, and the model learns slow.
+
+# 3.3 Burgers’ Equation
+
+The 1-D Burgers’ equation is a non-linear PDE occurring in various areas of applied mathematics. For a given field $u ( x , t )$ and diffusion coefficient $v$ , the 1-D Burgers’ equation reads:
+
+$$
+\begin{array} { c } { { \displaystyle \frac { \partial u } { \partial t } = - u \frac { \partial u } { \partial x } + v \frac { \partial ^ { 2 } u } { \partial x ^ { 2 } } , x \in ( 0 , 2 \pi ) , t \in ( 0 , 1 ] } } \\ { { u _ { 0 } ( x ) = u ( x , t = 0 ) . } } \end{array}
+$$
+
+The task for the neural operator is to learn the mapping of initial condition $u ( x , t = 0 )$ to the solutions at $= 1 \ : u ( x , t = 1 )$ . To compare with many advanced neural operators under the same conditions, we use the Burgers’ data and the results that have been published in [47] and [49]. The initial condition is sampled as Gaussian random fields where $u _ { 0 } \stackrel { . } { \sim } \mathcal { N } ( 0 , 5 ^ { 4 } ( - \bar { \Delta } + 5 ^ { 2 } I ) ^ { - 2 } )$ with periodic boundary conditions. $\Delta$ is the Laplacian, meaning the initial conditions are sampled by sampling its first several coefficients from a Gaussian distribution. In the Burgers’ equation, $v$ is set to 0.1. The equation is solved with resolution $2 ^ { 1 3 }$ , and the data with lower resolutions are obtained by sub-sampling the highest resolution data set.
+
+![](images/707f946f0e821cdf1670b8c04c9b49009a3d2712bcc1403f17f483486149fe4e.jpg)  
+Figure 5: Relative $L 2$ error vs epochs for MWT Leg with different number of OP basis $k = 1 , \ldots , 6$ .
+
+![](images/b31ea507ce568cca8fb98302ca37c0f3eee40e3502c6c92e3959fd7f3cb73bfd.jpg)  
+Figure 6: Burgers’ Equation validation at various input resolution $s$ . Our methods: MWT Leg, Chb.
+
+<table><tr><td>Networks</td><td>s=32</td><td>s=64</td><td>s=128</td><td>s= 256</td><td>s=512</td></tr><tr><td>MWT Leg</td><td>0.0152</td><td>0.00899</td><td>0.00747</td><td>0.00722</td><td>0.00654</td></tr><tr><td>MWT Chb</td><td>0.0174</td><td>0.0108</td><td>0.00872</td><td>0.00892</td><td>0.00891</td></tr><tr><td>MWTRnd</td><td>0.2435</td><td>0.2434</td><td>0.2434</td><td>0.2431</td><td>0.2432</td></tr><tr><td>FNO</td><td>0.0177</td><td>0.0121</td><td>0.0111</td><td>0.0107</td><td>0.0106</td></tr><tr><td>MGNO</td><td>0.0501</td><td>0.0519</td><td>0.0547</td><td>0.0542</td><td>-</td></tr><tr><td>LNO</td><td>0.0524</td><td>0.0457</td><td>0.0453</td><td>0.0428</td><td>=</td></tr></table>
+
+Table 2: Benchmarks on Darcy Flow equation at various input resolution s. Top: Our methods. MWT Rnd instantiate random entries of the filter matrices in (6)-(9). Bottom: prior works on Neural operator.
+
+The results of the experiments on Burgers’ equation for different resolutions are shown in Figure 6. Compared to any of the benchmarks, our MWT Leg obtains the lowest relative error, which is an order of magnitude lower than the state-of-the-art. It’s worth noting that even in the case of low resolution, MWT Leg still maintains a very low error rate, which shows its potential for learning the function mapping through low-resolution data, that is, the ability to map between infinite-dimensional spaces by learning a limited finite-dimensional spaces mapping.
+
+# 3.4 Darcy Flow
+
+Darcy flow formulated by Darcy[22] is one of the basic relationships of hydrogeology, describing the flow of a fluid through a porous medium. We experiment on the steady-state of the 2-d Darcy flow equation on the unit box, where it takes the following form:
+
+$$
+\begin{array} { r } { \nabla \cdot ( a ( x ) \nabla u ( x ) ) = f ( x ) , \quad x \in ( 0 , 1 ) ^ { 2 } } \\ { u ( x ) = 0 , \qquad x \in \partial ( 0 , 1 ) ^ { 2 } } \end{array}
+$$
+
+We set the experiments to learn the operator mapping the coefficient $a ( x )$ to the solution $u ( x )$ . The coefficients are generated according to $a \sim \mathcal { N } ( 0 , ( - \Delta + 3 ^ { 2 } I ) ^ { - 2 } )$ , where $\Delta$ is the Laplacian with zero Neumann boundary conditions. The threshold of $a ( x )$ is set to achieve ellipticity. The solutions $u ( x )$ are obtained by using a 2nd-order finite difference scheme on a $5 1 2 \times 5 1 2$ grid. Data sets of lower resolution are sub-sampled from the original data set.
+
+The results of the experiments on Darcy Flow for different resolutions are shown in Table2. MWT Leg again obtains the lowest relative error compared to other neural operators at various resolutions.
+
+We also perform an additional experiment, in which the multiwavelet filters $H ^ { ( i ) } , G ^ { ( i ) } , i = 0 , 1$ are replaced with random values (properly normalized). We see in Table 2, that MWT Rnd does not learn the operator map, in fact, its performance is worse than all the models. This signifies the importance of the careful choice of the filter matrices.
+
+# 3.5 Additional Experiments
+
+Full results for these experiments are provided in the supplementary materials.
+
+Navier Stokes Equation: The Navier-Stokes (NS) are 2d time-varying PDEs modeling the viscous, incompressible fluids. The proposed MWT model does a 2d multiwavelet transform for the velocity $u$ , while uses a single-layered 3d convolution for $A , B$ and $C$ to learn dependencies across space-time. We have observed that the proposed MWT Leg is in par with the Sota on the NS equations.
+
+Prediction at high resolution: We show that MWT model trained at lower resolutions for various datasets (for example, training with $s = 2 5 6$ for Burgers) can predict the output at finer resolutions $s = 2 0 4 8$ , with relative error of 0.0226, thus eliminating the need for expensive sampling. The training and testing with $s = 2 0 4 8$ yields a relative error of 0.00189.
+
+Train/evaluation with different sampling rules: We study the operator learning behavior when the training and evaluation datasets are obtained using the random function from different generating rules. The training is done with squared exponential kernel but evaluation is done on different generating rule [30] with controllable parameter $\lambda$ .
+
+# 4 Conclusion
+
+We address the problem of data-driven learning of the operator that maps between two function spaces. Motivated from the fundamental properties of the integral kernel, we found that multiwavelets constitute a natural basis to represent the kernel sparsely. After generalizing the multiwavelets to work with arbitrary measures, we proposed a series of models to learn the integral operator. This work opens up new research directions and possibilities toward designing efficient Neural operators utilizing properties of the kernels, and the suitable basis. We anticipate that the study of this problem will solve many engineering and biological problems such as aircraft wing design, complex fluids dynamics, metamaterials design, cyber-physical systems, neuron-neuron interactions that are modeled by complex PDEs.
+
+# Acknowledgement
+
+We are thankful to the anonymous reviewers for providing their valuable feedback which improved the manuscript. We would also like to thank Radu Balan for his valuable feedback. We gratefully acknowledge the support by the National Science Foundation Career award under Grant No. CPS/CNS-1453860, the NSF award under Grant CCF-1837131, MCB-1936775, CNS-1932620, the U.S. Army Research Office (ARO) under Grant No. W911NF-17-1-0076, the Okawa Foundation award, and the Defense Advanced Research Projects Agency (DARPA) Young Faculty Award and DARPA Director Award under Grant No. N66001-17-1-4044, an Intel faculty award and a Northrop Grumman grant. A part of this work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number ACI-1548562. The views, opinions, and/or findings contained in this article are those of the authors and should not be interpreted as representing the official views or policies, either expressed or implied by the Defense Advanced Research Projects Agency, the Army Research Office, the Department of Defense or the National Science Foundation.
+
+References   
+[1] M. Abramowitz and I.A. Stegun. Handbook of Mathematical Functions: With Formulas, Graphs, and Mathematical Tables. Applied mathematics series. Dover Publications, 1965. ISBN 9780486612720.   
+[2] Jonas Adler and Ozan Öktem. Solving ill-posed inverse problems using iterative deep neural networks. Inverse Problems, 33(12), Nov 2017. ISSN 1361-6420. doi: 10.1088/1361-6420/ aa9581. URL http://dx.doi.org/10.1088/1361-6420/aa9581.   
+[3] B. Alpert, G. Beylkin, R. Coifman, and V. Rokhlin. Wavelet-like bases for the fast solution of second-kind integral equations. SIAM Journal on Scientific Computing, 14(1):159–184, 1993. doi: 10.1137/0914010.   
+[4] B. Alpert, G. Beylkin, D. Gines, and L. Vozovoi. Adaptive solution of partial differential equations in multiwavelet bases. Journal of Computational Physics, 182(1):149–190, 2002. ISSN 0021-9991.   
+[5] Bradley K. Alpert. A class of bases in $L ^ { 2 }$ for the sparse representation of integral operators. SIAM Journal on Mathematical Analysis, 24(1):246–262, 1993. doi: 10.1137/0524016.   
+[6] Bradley K. Alpert and Vladimir Rokhlin. A fast algorithm for the evaluation of legendre expansions. SIAM Journal on Scientific and Statistical Computing, 12(1):158–179, 1991. doi: 10.1137/0912009.   
+[7] Kevin Amaratunga and John Williams. Wavelet based green’s function approach to 2d pdes. Engineering Computations, 10, 07 2001. doi: 10.1108/eb023913.   
+[8] Radu Balan, Bernhard G. Bodmann, Peter G. Casazza, and Dan Edidin. Painless reconstruction from magnitudes of frame coefficients. Journal of Fourier Analysis and Applications, 16: 488–501, 2009.   
+[9] J.J. Benedetto. Wavelets: Mathematics and Applications. Studies in Advanced Mathematics. Taylor & Francis, 1993. ISBN 9780849382710.   
+[10] G. Beylkin. On the representation of operators in bases of compactly supported wavelets. SIAM Journal on Numerical Analysis, 29(6):1716–1740, 1992. doi: 10.1137/0729097.   
+[11] G. Beylkin, R. Coifman, and V. Rokhlin. Fast wavelet transforms and numerical algorithms i. Communications on Pure and Applied Mathematics, 44(2):141–183, 1991. doi: https: //doi.org/10.1002/cpa.3160440202.   
+[12] Gregory Beylkłn and James M. Keiser. An adaptive pseudo-wavelet approach for solving nonlinear partial differential equations. In Multiscale Wavelet Methods for Partial Differential Equations, volume 6 of Wavelet Analysis and Its Applications, pages 137–197. Academic Press, 1997.   
+[13] Saakaar Bhatnagar, Yaser Afshar, Shaowu Pan, Karthik Duraisamy, and Shailendra Kaushik. Prediction of aerodynamic flow fields using convolutional neural networks. Computational Mechanics, 64(2):525–545, Jun 2019. ISSN 1432-0924. doi: 10.1007/s00466-019-01740-0.   
+[14] Kaushik Bhattacharya, Bamdad Hosseini, Nikola B. Kovachki, and Andrew M. Stuart. Model reduction and neural networks for parametric pdes, 2020.   
+[15] Nicolas Boulle, Christopher J. Earls, and Alex Townsend. Data-driven discovery of physical laws with human-understandable deep learning, 2021.   
+[16] Joseph Boussinesq. Essai sur la théorie des eaux courantes. Impr. nationale, 1877.   
+[17] R. Y. Chang and M. L. Wang. Shifted legendre direct method for variational problems. Journal of Optimization Theory and Applications, 39(2):299–307, Feb 1983. ISSN 1573-2878. doi: 10.1007/BF00934535.   
+[18] Zhengdao Chen, Jianyu Zhang, Martin Arjovsky, and Léon Bottou. Symplectic recurrent neural networks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=BkgYPREtPr.   
+[19] Kenneth C. Chou and Gary S. Guthart. Representation of green’s function integral operators using wavelet transforms. Journal of Vibration and Control, 6(1):19–48, 2000. doi: 10.1177/ 107754630000600102.   
+[20] N.M. Chuong. Pseudodifferential Operators and Wavelets over Real and $p$ -adic Fields. Springer International Publishing, 2018. ISBN 9783319774732.   
+[21] M. Cotronei, L.B. Montefusco, and L. Puccio. Multiwavelet analysis and signal processing. IEEE Transactions on Circuits and Systems II: Analog and Digital Signal Processing, 45(8): 970–987, 1998.   
+[22] Henry Darcy. Les fontaines publiques de la ville de Dijon: exposition et application... Victor Dalmont, 1856.   
+[23] Olivier Darrigol. Worlds of flow: A history of hydrodynamics from the Bernoullis to Prandtl. Oxford University Press, 2005.   
+[24] Ingrid Daubechies. Orthonormal bases of compactly supported wavelets. Communications on Pure and Applied Mathematics, 41(7):909–996, 1988. doi: https://doi.org/10.1002/cpa. 3160410705.   
+[25] Ingrid Daubechies. Ten Lectures on Wavelets. Society for Industrial and Applied Mathematics, 1992. doi: 10.1137/1.9781611970104.   
+[26] D. Deng, Y. Meyer, and Y. Han. Harmonic Analysis on Spaces of Homogeneous Type. Lecture Notes in Mathematics. Springer Berlin Heidelberg, 2008. ISBN 9783540887447.   
+[27] T. A Driscoll, N. Hale, and L. N. Trefethen. Chebfun Guide. Pafnuty Publications, 2014.   
+[28] Yuwei Fan, Jordi Feliu-Faba, Lin Lin, Lexing Ying, and Leonardo Zepeda-Nunez. A multiscale neural network based on hierarchical nested bases, 2019.   
+[29] Jordi Feliu-Fabà, Yuwei Fan, and Lexing Ying. Meta-learning pseudo-differential operators with deep neural networks. Journal of Computational Physics, 408:109309, May 2020. ISSN 0021-9991. doi: 10.1016/j.jcp.2020.109309.   
+[30] Silviu-Ioan Filip, Aurya Javeed, and Lloyd Trefethen. Smooth random functions, random odes, and gaussian processes. SIAM Review, 61:185–205, 01 2019. doi: 10.1137/17M1161853.   
+[31] Daniel Greenfeld, Meirav Galun, Ron Kimmel, Irad Yavneh, and Ronen Basri. Learning to optimize multigrid pde solvers, 2019.   
+[32] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Ré. Hippo: Recurrent memory with optimal polynomial projections. In Advances in Neural Information Processing Systems, volume 33, pages 1474–1487, 2020.   
+[33] Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, page 481–490. Association for Computing Machinery, 2016.   
+[34] Mustafa Hajij, Ghada Zamzmi, Matthew Dawson, and Greg Muller. Algebraically-informed deep networks (aidn): A deep learning approach to represent algebraic structures, 2021.   
+[35] M.H. Heydari, M.R. Hooshmandasl, and F. Mohammadi. Legendre wavelets method for solving fractional partial differential equations with dirichlet boundary conditions. Applied Mathematics and Computation, 234:267–276, 2014. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc. 2014.02.047.   
+[36] Chyi Hwang and Yen-Ping Shih. Solution of integral equations via laguerre polynomials. Computers & Electrical Engineering, 9(3):123–129, 1982. ISSN 0045-7906. doi: https: //doi.org/10.1016/0045-7906(82)90018-0.   
+[37] Ameya D. Jagtap, Yeonjong Shin, Kenji Kawaguchi, and George Em Karniadakis. Deep kronecker neural networks: A general framework for neural networks with adaptive activation functions, 2021.   
+[38] M. Tavassoli Kajani, A. Hadi Vencheh, and M. Ghasemi. The chebyshev wavelets operational matrix of integration and product operation matrix. International Journal of Computer Mathematics, 86(7):1118–1125, 2009. doi: 10.1080/00207160701736236.   
+[39] F. Khellat and S.A. Yousefi. The linear legendre mother wavelets operational matrix of integration and its application. Journal of the Franklin Institute, 343(2):181–190, 2006. ISSN 0016-0032. doi: https://doi.org/10.1016/j.jfranklin.2005.11.002.   
+[40] Yuehaw Khoo, Jianfeng Lu, and Lexing Ying. Solving parametric pde problems with artificial neural networks. European Journal of Applied Mathematics, 32(3):421–435, Jul 2020. ISSN 1469-4425.   
+[41] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series, 2020.   
+[42] Dmitrii Kochkov, Jamie A. Smith, Ayya Alieva, Qing Wang, Michael P. Brenner, and Stephan Hoyer. Machine learning–accelerated computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21), 2021. ISSN 0027-8424. doi: 10.1073/pnas.2101784118.   
+[43] Vasil Kolev, Todor Cooklev, and Fritz Keinert. Design of a simple orthogonal multiwavelet filter by matrix spectral factorization. Circuits, Systems, and Signal Processing, 39(4):2006–2041, Aug 2019.   
+[44] Samuel Lanthaler, Siddhartha Mishra, and George Em Karniadakis. Error estimates for deeponets: A deep learning framework in infinite dimensions, 2021.   
+[45] Yuanlu LI. Solving a nonlinear fractional differential equation using chebyshev wavelets. Communications in Nonlinear Science and Numerical Simulation, 15(9):2284–2292, 2010. ISSN 1007-5704. doi: https://doi.org/10.1016/j.cnsns.2009.09.020.   
+[46] Yuanlu Li and Weiwei Zhao. Haar wavelet operational matrix of fractional order integration and its applications in solving the fractional order differential equations. Applied Mathematics and Computation, 216(8):2276–2285, 2010. ISSN 0096-3003. doi: https://doi.org/10.1016/j. amc.2010.03.063.   
+[47] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Fourier neural operator for parametric partial differential equations, 2020.   
+[48] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Neural operator: Graph kernel network for partial differential equations, 2020.   
+[49] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Andrew Stuart, Kaushik Bhattacharya, and Anima Anandkumar. Multipole graph neural operator for parametric partial differential equations. In Advances in Neural Information Processing Systems, volume 33, pages 6755–6766, 2020.   
+[50] Lu Lu, Pengzhan Jin, and George Em Karniadakis. Deeponet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators, 2020.   
+[51] Lu Lu, Pengzhan Jin, Guofei Pang, Zhongqiang Zhang, and George Em Karniadakis. Learning nonlinear operators via deeponet based on the universal approximation theorem of operators. Nature Machine Intelligence, 3(3):218–229, Mar 2021. ISSN 2522-5839.   
+[52] Ryan McKeown, Rodolfo Ostilla-Mónico, Alain Pumir, Michael P. Brenner, and Shmuel M. Rubinstein. Turbulence generation through an iterative cascade of the elliptical instability. Science Advances, 6(9), 2020. doi: 10.1126/sciadv.aaz2717.   
+[53] Y. Meyer and D.H. Salinger. Wavelets and Operators: Volume 1. Cambridge Studies in Advanced Mathematics. Cambridge University Press, 1992. ISBN 9780521458696.   
+[54] Y. Meyer, R. Coifman, and D. Salinger. Wavelets: Calderón-Zygmund and Multilinear Operators. Cambridge Studies in Advanced Mathematics. Cambridge University Press, 1997. ISBN 9780521420013.   
+[55] Guillaume Ovarlez, Anh Vu Nguyen Le, Wilbert J. Smit, Abdoulaye Fall, Romain Mari, Guillaume Chatté, and Annie Colin. Density waves in shear-thickening suspensions. Science Advances, 6(16), 2020. doi: 10.1126/sciadv.aay5589.   
+[56] Ravi G. Patel, Nathaniel A. Trask, Mitchell A. Wood, and Eric C. Cyr. A physics-informed operator regression framework for extracting data-driven continuum models. Computer Methods in Applied Mechanics and Engineering, 373:113500, 2021. ISSN 0045-7825. doi: https: //doi.org/10.1016/j.cma.2020.113500.   
+[57] M. Raissi, P. Perdikaris, and G.E. Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial
+
+differential equations. Journal of Computational Physics, 378:686–707, 2019. ISSN 0021-
+
+9991.   
+[58] C.E. Rasmussen and C.K.I. Williams. Gaussian Processes for Machine Learning. Adaptative computation and machine learning series. University Press Group Limited, 2006.   
+[59] Mohsen Razzaghi and Samira Yousefi. The legendre wavelets operational matrix of integration. International Journal of Systems Science, 32:495–502, 04 2001. doi: 10.1080/00207720120227.   
+[60] M. F. Shlesinger, B. J. West, and J. Klafter. Lévy dynamics of enhanced diffusion: Application to turbulence. Phys. Rev. Lett., 58:1100–1103, Mar 1987. doi: 10.1103/PhysRevLett.58.1100.   
+[61] B. W. Silverman, J. C. Vassilicos, and Nick Kingsbury. Image processing with complex wavelets. Philosophical Transactions of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 357(1760):2543–2560, 1999. doi: 10.1098/rsta.1999.0447.   
+[62] S. Timoshenko. History of Strength of Materials: With a Brief Account of the History of Theory of Elasticity and Theory of Structures. Dover Civil and Mechanical Engineering Series. Dover Publications, 1983. ISBN 9780486611877.   
+[63] J. Towns, T. Cockerill, M. Dahan, I. Foster, K. Gaither, A. Grimshaw, V. Hazlewood, S. Lathrop, D. Lifka, G. D. Peterson, R. Roskies, J. R. Scott, and N. Wilkins-Diehr. Xsede: Accelerating scientific discovery. Computing in Science & Engineering, 16(5):62–74, Sept.-Oct. 2014. ISSN 1521-9615. doi: 10.1109/MCSE.2014.80. URL doi.ieeecomputersociety.org/10.1109/ MCSE.2014.80.   
+[64] Lifeng Wang, Yunpeng Ma, and Zhijun Meng. Haar wavelet method for solving fractional partial differential equations numerically. Applied Mathematics and Computation, 227:66–76, 2014. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc.2013.11.004.   
+[65] Sifan Wang, Hanwen Wang, and Paris Perdikaris. Learning the solution operator of parametric partial differential equations with physics-informed deeponets, 2021.   
+[66] Yanxin Wang and Qibin Fan. The second kind chebyshev wavelet method for solving fractional differential equations. Applied Mathematics and Computation, 218(17):8592–8601, 2012. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc.2012.02.022.   
+[67] Shiying Xiong, Xingzhe He, Yunjin Tong, and Bo Zhu. Neural vortex method: from finite lagrangian particles to infinite dimensional eulerian dynamics, 2020.   
+[68] Yuankun Xue and Paul Bogdan. Constructing compact causal mathematical models for complex dynamics. In 2017 ACM/IEEE 8th International Conference on Cyber-Physical Systems (ICCPS), pages 97–108, April 2017.   
+[69] Li Zhu and Yanxin Wang. Solving fractional partial differential equations by using the second chebyshev wavelet operational matrix method. Nonlinear Dynamics, 89(3):1915–1925, Aug 2017. ISSN 1573-269X. doi: 10.1007/s11071-017-3561-7.   
+[70] Li Zhu and Yanxin Wang. Solving fractional partial differential equations by using the second chebyshev wavelet operational matrix method. Nonlinear Dynamics, 89(3):1915–1925, Aug 2017. ISSN 1573-269X. doi: 10.1007/s11071-017-3561-7.   
+[71] Yinhao Zhu and Nicholas Zabaras. Bayesian deep convolutional encoder–decoder networks for surrogate modeling and uncertainty quantification. Journal of Computational Physics, 366: 415–447, Aug 2018. ISSN 0021-9991.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] For example, see Table 1 2, Figure 6 for benchmarks on the datasets. Also, see Figure 3 for robustness plot, and Figure 5 for theoretical insights for pseudo-differential operators.   
+(b) Did you describe the limitations of your work? [Yes] We discuss in details the possible numerical issues that can occur in estimating the filter matrices ${ \cal H } ^ { ( 0 ) } , { \cal H } ^ { ( 1 ) } , { \cal G } ^ { \bar { ( 0 ) } } , { \cal G } ^ { ( 1 ) }$ for large values of $k$ . The issue is not related to the mathematics involved but due to the nature of floating-point precision. We discuss this in details in the supplementary materials.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] Please refer to Section 2.2, where we list all the necessary derived results, while we have referred the reader (at appropriate places) to the supplementary materials for the complete details.   
+(b) Did you include complete proofs of all theoretical results? [Yes] We provide detailed derivations of all the measure dependent filter matrices ${ \cal H } ^ { ( 0 ) } , { \cal H } ^ { ( 1 ) } , { \cal G } ^ { ( \bar { 0 } ) } , { \cal G } ^ { ( 1 ) }$ and also the correction terms $\Sigma ^ { ( 0 ) } , \Sigma ^ { ( 1 ) }$ in the supplementary materials.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code is uploaded with the supplementary materials.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Please refer to Section 3 where we list all of the details regarding training and model architectures.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All the results included in the paper are averaged over a total of 3 seeds. We have also mentioned the same in Section 3.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All of the experiments were performed on a single Nvidia V100 32 GB GPU, please refer to Section 3.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] A part of the datasets are taken from the FNO work [47], while some are generated using the scripts provided by the same authors. We have properly cited the work in Section 3 Benchmark models.   
+(b) Did you mention the license of the assets? [N/A] A part of the code and datasets ([47]) used by us are openly available with no license restriction, to the best of our knowledge.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] The code and the dataset is openly available.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] All the datasets are synthetically generated.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/LZDiWaC9CGL/LZDiWaC9CGL_content_list.json

@@ -0,0 +1,1377 @@
+[
+    {
+        "type": "text",
+        "text": "Multiwavelet-based Operator Learning for Differential Equations ",
+        "text_level": 1,
+        "bbox": [
+            240,
+            122,
+            758,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gaurav Gupta, Xiongye Xiao, Paul Bogdan Ming Hsieh Department of Electrical and Computer Engineering University of Southern California, Los Angeles, CA 90089 {ggaurav, xiongyex, pbogdan}@usc.edu ",
+        "bbox": [
+            287,
+            226,
+            712,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The solution of a partial differential equation can be obtained by computing the inverse operator map between the input and the solution space. Towards this end, we introduce a multiwavelet-based neural operator learning scheme that compresses the associated operator’s kernel using fine-grained wavelets. By explicitly embedding the inverse multiwavelet filters, we learn the projection of the kernel onto fixed multiwavelet polynomial bases. The projected kernel is trained at multiple scales derived from using repeated computation of multiwavelet transform. This allows learning the complex dependencies at various scales and results in a resolution-independent scheme. Compare to the prior works, we exploit the fundamental properties of the operator’s kernel which enable numerically efficient representation. We perform experiments on the Korteweg-de Vries (KdV) equation, Burgers’ equation, Darcy Flow, and Navier-Stokes equation. Compared with the existing neural operator approaches, our model shows significantly higher accuracy and achieves state-of-the-art in a range of datasets. For the time-varying equations, the proposed method exhibits a $( 2 X - 1 0 X )$ improvement (0.0018 (0.0033) relative $L 2$ error for Burgers’ (KdV) equation). By learning the mappings between function spaces, the proposed method has the ability to find the solution of a high-resolution input after learning from lower-resolution data. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            310,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many natural and human-built systems (e.g., aerospace, complex fluids, neuro-glia information processing) exhibit complex dynamics characterized by partial differential equations (PDEs) [52, 60]. For example, the design of wings and airplanes robust to turbulence, requires to learn complex PDEs. Along the same lines, complex fluids (gels, emulsions) are multiphasic materials characterized by a macroscopic behavior [55] modeled by non-linear PDEs. Understanding their variations in viscosity as a function of the shear rate is critical for many engineering projects. Moreover, modeling the dynamics of continuous and discrete cyber and physical processes in complex cyber-physical systems can be achieved through PDEs [68]. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent efforts on learning PDEs (i.e., mappings between infinite-dimensional spaces of functions), from trajectories of variables, focused on developing machine learning and in particular deep neural networks (NNs) techniques. Towards this end, a stream of work aims at parameterizing the solution map as deep NNs [2, 13, 33, 40, 71]. One issue, however, is that the NNs are tied to a specific resolution during training, and therefore, may not generalize well to other resolutions, thus, requiring retraining (and possible modifications of the model) for every set of discretizations. In parallel, another stream of work focuses on constructing the PDE solution function as a NN architecture [31, 42, 57, 65]. This approach, however, is designed to work with one instance of a PDE and, therefore, upon changing the coefficients associated with the PDE, the model has to be re-trained. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Additionally, the approach is not a complete data-dependent one, and hence, cannot be made oblivious to the knowledge of the underlying PDE structure. Finally, the closest stream of work to the problem we investigate is represented by the “Neural Operators\" [14, 47, 48, 49, 56]. Being a complete data-driven approach, the neural operators method aims at learning the operator map without having knowledge of the underlying PDEs. The neural operators have also demonstrated the capability of discretization-independence. Obtaining the data for learning the operator map could be prohibitively expensive or time consuming (e.g., aircraft performance to different initial conditions). To be able to better solve the problem of learning the PDE operators from scarce and noisy data, we would ideally explore fundamental properties of the operators that have implications in data-efficient representation. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our intuition is to transform the problem of learning a PDE to a domain where a compact representation of the operator exists. With a mild assumption regarding the smoothness of the operator’s kernel, except finitely many singularities, the multiwavelets [5], with their vanishing moments property, sparsify the kernel in their projection with respect to (w.r.t.) a measure. Therefore, learning an operator kernel in the multiwavelet domain is feasible and data efficient. The wavelets have a rich history in signal processing [24, 25], and are popular in audio, image compression [8, 61]. For multiwavelets, the orthogonal polynomial (OP) w.r.t. a measure emerges as a natural basis for the multiwavelet subspace, and an appropriate scale / shift provides a sequence of subspaces which captures the locality at various resolutions. We generalize and exploit the multiwavelets concept to work with arbitrary measures which opens-up new possibilities to design a series of models for the operator learning from complex data streams. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We incorporate the multiwavelet filters derived using a variety of the OP basis into our operator learning model, and show that the proposed architecture outperforms the existing neural operators. Our main contributions are as follows: (i) Based on some fundamental properties of the integral operator’s kernel, we develop a multiwavelet-based model which learns the operator map efficiently. (ii) For the 1-D dataset of non-linear Korteweg-de Vries and Burgers equations, we observe an order of magnitude improvement in the relative $L 2$ error (Section 3.1, 3.3). (iii) We demonstrate that the proposed model is in validation with the theoretical properties of the pseudo-differential operator (Section 3.2). (iv) We show how the proposed multiwavelet-based model is robust towards the fluctuation strength of the input signal (Section 3.1). (v) Next, we demonstrate the applicability on higher dimensions of 2-D Darcy flow equation (Section 3.4), and finally show that the proposed approach can learn at lower resolutions and generalize to higher resolutions. The code for reproducing the experiments is available at: https://github.com/gaurav71531/mwt-operator. ",
+        "bbox": [
+            173,
+            380,
+            825,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Operator Learning using Multiwavelet Transform ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            622,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by defining the problem of operator learning in Section 2.1. Section 2.2 defines the multiwavelet transform for the proposed operator learning problem and derives the necessary transformation operations across different scales. Section 2.3 outlines the proposed operator learning model. Finally, Section 2.4 lists some of the useful properties of the operators which leads to an efficient implementation of multiwavelet-based models. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Problem Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            316,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given two functions $a ( x )$ and $u ( x )$ with $x \\in D$ , the operator is a map $T$ such that $T a = u$ . Formally, let $\\mathcal { A }$ and $\\mathcal { U }$ be two Sobolev spaces $\\mathcal { H } ^ { s , p }$ $( s > 0 , p \\ge 1 )$ ), then the operator $T$ is such that $T : { \\mathcal { A } }  { \\mathcal { U } }$ . The Sobolev spaces are particularly useful in the analysis of partial differential equations (PDEs), and we restrict our attention to $s > 0$ and $p = 2$ . Note that, for $s = 0$ , the $\\mathcal { H } ^ { 0 , p }$ coincides with $L ^ { p }$ , and, $f \\in \\mathcal { H } ^ { 0 , p }$ does not necessarily have derivatives in $L ^ { p }$ . We choose $p = 2$ in order to be able to define projections with respect to (w.r.t.) measures $\\mu$ in a Hilbert space structure. ",
+        "bbox": [
+            174,
+            707,
+            826,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We take the operator $T$ as an integral operator with the kernel $K : D \\times D  L ^ { 2 }$ such that ",
+        "bbox": [
+            171,
+            796,
+            763,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d552b40e053bdc72f0712d48b5715794901eb320dfa54511d48c4e8a2bf9099.jpg",
+        "text": "$$\nT a ( x ) = \\int _ { D } K ( x , y ) a ( y ) d y .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            818,
+            596,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the case of inhomogeneous linear PDEs, $\\mathcal { L } u = f$ , with $f$ being the forcing function, $\\mathcal { L }$ is the differential operator, and the associated kernel is commonly termed as Green function. In our case, we do not put the restriction of linearity on the operator. From eq. (1), it is apparent that learning the complete kernel $K ( . , . )$ would essentially solve the operator map problem, but it is not necessarily a numerically feasible solution. Indeed, a better approach would be to exploit possible useful properties (see Section 2.4) such that a compact representation of the kernel can be made. For an efficient representation of the operator kernel, we need an appropriate subspace (or sequence of subspaces), and projection tools to map to such spaces. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Norm with respect to measures: Projecting a given function onto a fixed basis would require a measure dependent distance. For two functions $f$ and $g$ , we take the inner product w.r.t measure $\\mu$ as $\\begin{array} { r } { { \\langle f , g \\rangle _ { \\mu } = \\int f ( x ) g ( x ) d \\mu ( x ) } } \\end{array}$ , and the associated norm as $\\vert \\vert f \\vert \\vert _ { \\mu } = \\langle f , f \\rangle _ { \\mu } ^ { 1 / 2 }$ . We now discuss the next ingredient, which refers to the subspaces required to project the kernel. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            213
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Multiwavelet Transform ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            228,
+            382,
+            243
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly overview the concept of multiwavelets [4] and extend it to work with nonuniform measures at each scale. The multiwavelet transform synergizes the advantages of orthogonal polynomials (OPs) as well as the wavelets concepts, both of which have a rich history in the signal processing. The properties of wavelet bases like $( i )$ vanishing moments, and $( i i )$ orthogonality can effectively be used to create a system of coordinates in which a wide class of operators (see Section 2.4) have a nice representation. Multiwavelets go few steps further, and provide a fine-grained representation using OPs, but also act as a basis on a finite interval. For the rest of this section, we restrict our attention to the interval $[ 0 , 1 ]$ ; however, the transformation to any finite interval $[ a , b ]$ could be straightforwardly obtained by an appropriate shift and scale. ",
+        "bbox": [
+            173,
+            253,
+            826,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi Resolution Analysis: We begin by defining the space of piecewise polynomial functions, for $k \\in \\mathbb N$ and $n \\in \\mathbb { Z } ^ { + } \\cup \\{ 0 \\}$ as, $\\begin{array} { r } { \\mathbf { V } _ { n } ^ { k } = \\bigcup _ { l = 0 } ^ { 2 ^ { n } - 1 } \\{ f | \\deg ( f ) < k } \\end{array}$ for $x \\in ( 2 ^ { - n } l , 2 ^ { - n } ( l + 1 ) ) \\land$ 0, elsewhere $\\}$ . Clearly, $\\dim ( \\mathbf { V } _ { n } ^ { k } ) \\ : = \\ : 2 ^ { n } k$ , and for subsequent $n$ , each subspace is contained in another as shown by the following relation: ",
+        "bbox": [
+            173,
+            383,
+            825,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40f42603bf7d5f7cad71e396f741d3e36c68e469c85571607343920bf958efe8.jpg",
+        "text": "$$\n\\mathbf { V } _ { 0 } ^ { k } \\subset \\mathbf { V } _ { 1 } ^ { k } \\ldots \\subset \\mathbf { V } _ { n - 1 } ^ { k } \\subset \\mathbf { V } _ { n } ^ { k } \\subset \\ldots .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            452,
+            622,
+            473
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we define the sequence of measures $\\mu _ { 0 } , \\mu _ { 1 } , \\ldots$ such that $f \\in \\mathbf { V } _ { n } ^ { k }$ is measurable w.r.t. $\\mu _ { n }$ and the norm of $f$ is taken as $| | f | | = \\langle f , f \\rangle _ { \\mu _ { n } } ^ { 1 / 2 }$ . Next, since $\\mathbf { V } _ { n - 1 } ^ { k } \\subset \\mathbf { V } _ { n } ^ { k }$ , we define the multiwavelet subspace as $\\mathbf { W } _ { n } ^ { k }$ for $n \\in \\mathbb { Z } ^ { + } \\cup \\{ 0 \\}$ , such that ",
+        "bbox": [
+            173,
+            479,
+            825,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6de0789a63f4ec4a7a73106ba15aaa15bc6d7fc48e9ccda65fc7ee227dd5a48f.jpg",
+        "text": "$$\n\\mathbf { V } _ { n + 1 } ^ { k } = \\mathbf { V } _ { n } ^ { k } \\bigoplus \\mathbf { W } _ { n } ^ { k } , \\quad \\mathbf { V } _ { n } ^ { k } \\bot \\mathbf { W } _ { n } ^ { k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            536,
+            624,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a given OP basis for $\\mathbf { V } _ { 0 } ^ { k }$ as $\\phi _ { 0 } , \\phi _ { 1 } , \\ldots , \\phi _ { k - 1 }$ w.r.t. measure $\\mu _ { 0 }$ , a basis of the subsequent spaces $\\mathbf { V } _ { n } ^ { k } , n > 1$ can be obtained by shift and scale (hence the name, multi-scale) operations of the original basis as follows: ",
+        "bbox": [
+            173,
+            568,
+            825,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67e3d1805ffb6cbf8cbd5c258ede54f89df2da06ace2bb9fc449623960da49d7.jpg",
+        "text": "$$\n\\phi _ { j l } ^ { n } ( x ) = 2 ^ { n / 2 } \\phi _ { j } ( 2 ^ { n } x - l ) , \\quad j = 0 , 1 , \\ldots , k - 1 , \\quad l = 0 , 1 , \\ldots , 2 ^ { n } - 1 , \\mathrm { w . r . t . } \\quad \\mu _ { n } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            628,
+            779,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where, $\\mu _ { n }$ is obtained as the collections of shift and scale of $\\mu _ { 0 }$ , accordingly. ",
+        "bbox": [
+            173,
+            657,
+            678,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multiwavelets: For the multiwavelet subspace $\\mathbf { W } _ { 0 } ^ { k }$ , the orthonormal basis (of piecewise polynomials) are taken as $\\psi _ { 0 } , \\psi _ { 1 } , \\dots , \\psi _ { k - 1 }$ such that $\\langle \\psi _ { i } , \\psi _ { j } \\rangle _ { \\mu _ { 0 } } = 0$ for $i \\neq j$ and 1, otherwise. From eq. (3), $\\mathbf { V } _ { n } ^ { k } \\perp \\mathbf { W } _ { n } ^ { k }$ , and since $\\mathbf { V } _ { n } ^ { k }$ spans the polynomials of degree at most $k$ , therefore, we conclude that ",
+        "bbox": [
+            174,
+            678,
+            826,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c11c700d84406f58449383f6766e329a7455cf72cbe8a7f5c4da95143179fe72.jpg",
+        "text": "$$\n\\int _ { 0 } ^ { 1 } x ^ { i } \\psi _ { j } ( x ) d \\mu _ { 0 } ( x ) = 0 , \\quad \\forall 0 \\leq j , i < k .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            739,
+            552,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similarly to eq. (4), a basis for multiwavelet subspace $\\mathbf { W } _ { n } ^ { k }$ are obtained by shift and scale of $\\psi _ { i }$ as $\\psi _ { j l } ^ { n } ( x ) = 2 ^ { n / 2 } \\psi _ { j } ( 2 ^ { n } x - l )$ and $\\psi _ { j l } ^ { n }$ are orthonormal w.r.t. measure $\\mu _ { n }$ , i.e. $\\langle \\psi _ { j l } ^ { n } , \\psi _ { j ^ { \\prime } l ^ { \\prime } } ^ { n } \\rangle _ { \\mu _ { n } } = 1$ if $j = j ^ { \\prime } , l = l ^ { \\prime }$ , and 0 otherwise. Therefore, for a given OP basis for $\\mathbf { V } _ { 0 } ^ { k }$ (for example, Legendre, Chebyshev polynomials), we only require to compute $\\psi _ { i }$ , and a complete basis set at all the scales can be obtained using scale/shift of $\\phi _ { i } , \\psi _ { i }$ . ",
+        "bbox": [
+            173,
+            799,
+            826,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note: Since $\\mathbf { V } _ { 1 } ^ { k } = \\mathbf { V } _ { 0 } ^ { k } \\oplus \\mathbf { W } _ { 0 } ^ { k }$ from eq. (3), therefore, for a given basis $\\phi _ { i }$ of $\\mathbf { V } _ { 0 } ^ { k }$ w.r.t. measure $\\mu _ { 0 }$ and $\\phi _ { j l } ^ { n }$ as a basis for $\\mathbf { V } _ { 1 } ^ { k }$ w.r.t. $\\mu _ { 1 }$ , a set of basis $\\psi _ { i }$ can be obtained by applying Gram-Schmidt ",
+        "bbox": [
+            173,
+            881,
+            821,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/077eaacf6a88d1416897b372fd0c11cc0b20d5dcce8fd8b7b7b79f223c5dffb2.jpg",
+        "image_caption": [
+            "Figure 1: Multiwavelet representation of the Kernel. (i) Given kernel $K ( x , y )$ of an integral operator $T$ , (ii) the bases with different measures $( \\mu _ { 0 } , \\mu _ { 1 } )$ at two different scales (coars ${ \\mathrm { : = } } 0$ , fine $^ { = 1 }$ ) projects the kernel into 3 components $A _ { i } , B _ { i } , C _ { i }$ . (iii) The decomposition yields a sparse structure, and the entries with absolute magnitude values exceeding $1 e ^ { - 8 }$ are shown in black. Given projections at any scale, the finer / coarser scale projections can be obtained by reconstruction $/$ decomposition using a fixed multiwavelet filters $H ^ { ( i ) }$ and $\\mathbf { \\bar { \\cal G } } ^ { ( i ) } , i = 0 , 1$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            823,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Orthogonalization using appropriate measures. We refer the reader to supplementary materials for the detailed procedure. ",
+        "bbox": [
+            173,
+            455,
+            823,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note: Since $\\mathbf { V } _ { 0 } ^ { k }$ and $\\mathbf { W } _ { 0 } ^ { k }$ lives in $\\mathbf { V } _ { 1 } ^ { k }$ , therefore, $\\phi _ { i } , \\psi _ { i }$ can be written as a linear combination of the basis of $V _ { 1 } ^ { k }$ . We term these linear coefficients as multiwavelet decomposition filters $( H ^ { ( 0 ) } , H ^ { ( 1 ) } , G ^ { ( 0 ) } , G ^ { ( 1 ) } )$ , since they are transforming a fine $n = 1$ to coarse scale $n = 0$ . A uniform measure $\\left( \\mu _ { 0 } \\right)$ version is discussed in [4], and we extend it to any arbitrary measure by including the correction terms $\\Sigma ^ { ( 0 ) }$ and $\\Sigma ^ { ( 1 ) }$ . We refer to supplementary materials for the complete details. The capability of using the non-uniform measures enables us to apply the same approach to any OP basis with finite domain, for example, Chebyshev, Gegenbauer, etc. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a given $[ \\langle f , \\phi _ { i l } ^ { n } \\rangle _ { \\mu _ { n } } ] _ { i = 0 } ^ { k - 1 }$ $f ( x )$ , ${ \\bf d } _ { l } ^ { n } = [ \\langle f , \\psi _ { i l } ^ { n } \\rangle _ { \\mu _ { n } } ] _ { i = 0 } ^ { k - 1 }$ , the multiscale, multiwavelet coefficients at the scale , respectively, w.r.t. measure $\\mu _ { n }$ with $n$ $\\mathbf { s } _ { l } ^ { n } , \\mathbf { d } _ { l } ^ { n } \\in \\mathbb { R } ^ { k \\times 2 ^ { n } }$ are defined as $\\mathbf { s } _ { l } ^ { n } \\mathbf { \\Psi } =$ l . The decomposition / reconstruction across scales is written as ",
+        "bbox": [
+            173,
+            598,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7408f12a8b4002b3ad0dc2f8d17701f3816f49297b38ddad9365629ecc18ae7d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathbf { s } _ { l } ^ { n } = H ^ { ( 0 ) } \\mathbf { s } _ { 2 l } ^ { n + 1 } + H ^ { ( 1 ) } \\mathbf { s } _ { 2 l + 1 } ^ { n + 1 } , \\quad } & { ( 6 ) \\qquad \\mathbf { s } _ { 2 l } ^ { n + 1 } = \\Sigma ^ { ( 0 ) } ( H ^ { ( 0 ) T } \\mathbf { s } _ { l } ^ { n } + G ^ { ( 0 ) T } \\mathbf { d } _ { l } ^ { n } ) , } \\\\ { \\mathbf { d } _ { l } ^ { n } = G ^ { ( 0 ) } \\mathbf { s } _ { 2 l } ^ { n + 1 } + H ^ { ( 1 ) } \\mathbf { s } _ { 2 l + 1 } ^ { n + 1 } . \\quad } & { ( 7 ) \\qquad \\mathbf { s } _ { 2 l + 1 } ^ { n + 1 } = \\Sigma ^ { ( 1 ) } ( H ^ { ( 1 ) T } \\mathbf { s } _ { l } ^ { n } + G ^ { ( 1 ) T } \\mathbf { d } _ { l } ^ { n } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            656,
+            779,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The wavelet (and also multiwavelet) transformation can be straightforwardly extended to multiple dimensions using tensor product of the bases. For our purpose, a function $\\dot { \\boldsymbol { f } } \\in \\mathbb { R } ^ { d }$ has multiscale, multiwavelet coefficients $\\bar { \\mathbf { s } } _ { l } ^ { n } , \\mathbf { d } _ { l } ^ { n } \\in \\mathbb { R } ^ { k \\times \\ldots \\times k \\times 2 ^ { n } }$ which are also recursively obtained by replacing the filters in eq. (6)-(7) with their Kronecker product, specifically, $H ^ { ( 0 ) }$ with $H ^ { ( 0 ) } \\otimes H ^ { ( 0 ) } \\otimes . . . H ^ { ( 0 ) }$ , where $\\otimes$ is the Kronecker product repeated $d$ times. For eq. (8)-(9) $H ^ { ( 0 ) } \\Sigma ^ { ( 0 ) }$ (and similarly others) are replaced with their $d$ -times Kronecker product. ",
+        "bbox": [
+            174,
+            704,
+            826,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Non-Standard Form: The multiwavelet representation of the operator kernel $K ( x , y )$ can be obtained by an appropriate tensor product of the multiscale and multiwavelet basis. One issue, however, in this approach, is that the basis at various scales are coupled because of the tensor product. To untangle the basis at various scales, we use a trick as proposed in [11] called the non-standard wavelet representation. The extra mathematical price paid for the non-standard representation, actually serves as a ground for reducing the proposed model complexity (see Section 2.3), thus, providing data efficiency. For the operator under consideration $T$ with integral kernel $K ( x , y )$ , let us denote $T _ { n }$ as the projection of $T$ on $V _ { n } ^ { k }$ , which essentially is obtained by projecting the kernel $K$ onto basis $\\phi _ { j l } ^ { n }$ w.r.t. measure $\\mu _ { n }$ . If $P _ { n }$ is the projection operator such that $\\begin{array} { r } { P _ { n } f = \\sum _ { j , l } \\langle f , \\phi _ { j l } ^ { n } \\rangle _ { \\mu _ { n } } \\phi _ { j l } ^ { n } } \\end{array}$ , then $\\check { T _ { n } } = P _ { n } T P _ { n }$ . Using telescopic sum, $T _ { n }$ is expanded as ",
+        "bbox": [
+            173,
+            799,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0921619ef9d37acae33bddd11b5deaf1404fb4733447777da7368c77060d2447.jpg",
+        "image_caption": [
+            "Figure 2: MWT model architecture. (Left) Decomposition cell using 4 neural networks (NNs) $A , B$ and $C$ , and $T$ (for the coarsest scale $L$ ) performs multiwavelet decomposition from scale $n + 1$ to $_ n$ . (Right) Reconstruction module using pre-defined filters $H ^ { ( i ) } , G ^ { ( i ) }$ performs inverse multiwavelet transform from scale $n - 1$ to $n$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            88,
+            792,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            338,
+            823,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15e217275c7ddc396b00ae7c010e7f6bdbfdd1608c42efffa7782c5661ae2008.jpg",
+        "text": "$$\nT _ { n } = \\sum _ { i = L + 1 } ^ { n } ( Q _ { i } T Q _ { i } + Q _ { i } T P _ { i - 1 } + P _ { i - 1 } T Q _ { i } ) + P _ { L } T P _ { L } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            377,
+            704,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where, $Q _ { i } = P _ { i } - P _ { i - 1 }$ and $L$ is the coarsest scale under consideration $( L \\geq 0 )$ . From eq. (3), it is apparent that $Q _ { i }$ is the multiwavelet operator. Next, we denote $A _ { i } = Q _ { i } { \\cal T } Q _ { i } , B _ { i } = Q _ { i } { \\cal T } P _ { i - 1 } , C _ { i } =$ $P _ { i - 1 } T Q _ { i }$ , and $\\bar { T } = P _ { L } T P _ { L }$ . In Figure 1, we show the non-standard multiwavelet transform for a given kernel $K ( x , y )$ . The transformation has a sparse banded structure due to smoothness property of the kernel (see Section 2.4). For the operator $T$ such that $T a = u$ , the map under multiwavelet domain is written as ",
+        "bbox": [
+            173,
+            411,
+            825,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee07b7fcb6b701ab5a6c0be72d0cafc02a7a4ceec5aeec3df4e66f2ce8c06f44.jpg",
+        "text": "$$\nU _ { d l } ^ { n } = A _ { n } d _ { l } ^ { n } + B _ { n } s _ { l } ^ { n } , \\qquad U _ { \\hat { s } l } ^ { n } = C _ { n } d _ { l } ^ { n } , \\qquad U _ { s l } ^ { L } = \\bar { T } s _ { l } ^ { L } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            501,
+            686,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where, $( U _ { s l } ^ { n } , U _ { d l } ^ { n } ) / ( s _ { l } ^ { n } , d _ { l } ^ { n } )$ are the multiscale, multiwavelet coefficients of $u / a$ , respectively, and $L$ is the coarsest scale under consideration. With these mathematical concepts, we now proceed to define our multiwavelet-based operator learning model in the Section 2.3. ",
+        "bbox": [
+            173,
+            527,
+            826,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 Multiwavelet-based Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            397,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the discussion in Section 2.2, we propose a multiwavelet-based model (MWT) as shown in Figure 2. For a given input/output as $a / u$ , the goal of the MWT model is to map the multiwavelettransform of the input $( \\bar { s } _ { l } ^ { N } )$ to output $( U _ { s l } ^ { N } )$ at the finest scale $N$ . The model consists of two parts: (i) Decomposition $( d e c )$ , and $( i i )$ Reconstruction (rec). The dec acts as a recurrent network, and at each iteration the input is $s ^ { n + 1 }$ . Using (6)-(7), the input is used to obtain multiscale and multiwavelet coefficients at a coarser level $s ^ { n }$ and $d ^ { n }$ , respectively. Next, to compute the multiscale/multiwavelet coefficients of the output $u$ , we approximate the non-standard kernel decomposition from (11) using four neural networks (NNs) $A , B , C$ and $\\bar { T }$ such that $U _ { d l } ^ { n } \\approx A _ { \\theta _ { A } } ( d _ { l } ^ { n } ) \\stackrel { - } { + } B _ { \\theta _ { B } } ( s _ { l } ^ { n } ) , U _ { \\hat { s } l } ^ { n } \\approx$ $C _ { \\theta _ { C } } ( d _ { l } ^ { n } ) , \\forall 0 \\leq n < L$ , and $U _ { s l } ^ { L } \\approx \\bar { T } _ { \\theta _ { \\bar { T } } } ( s _ { l } ^ { L } )$ . This is a ladder-down approach, and the dec part performs the decimation of signal (factor $\\bar { 1 } / 2$ ), running for a maximum of $L$ cycles, $L < \\log _ { 2 } ( M )$ for a given input sequence of size $M$ . Finally, the rec module collects the constituent terms $U _ { s l } ^ { n } , U _ { \\hat { s } l } ^ { n } , U _ { d l } ^ { n }$ (obtained using the dec module) and performs a ladder-up operation to compute the multiscale coefficients of the output at a finer scale $n + 1$ using (8)-(9). The iterations continue until the finest scale $N$ is obtained for the output. ",
+        "bbox": [
+            173,
+            612,
+            826,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At each iteration, the filters in dec module downsample the input, but compared to popular techniques (e.g., maxpool), the input is only transformed to a coarser multiscale/multiwavelet space. By virtue of its design, since the non-standard wavelet representation does not have inter-scale interactions, it basically allows us to reuse the same kernel NNs $A , B , C$ at different scales. A follow-up advantage of this approach is that the model is resolution independent, since the recurrent structure of dec is input invariant, and for a different input size $M$ , only the number of iterations would possibly change for a maximum of $\\log _ { 2 } M$ . The reuse of $A , B , C$ by re-training at various scales also enable us to learn an expressive model with fewer parameters $( \\theta _ { A } , \\theta _ { B } , \\theta _ { C } , \\theta _ { \\bar { T } } )$ . We see in Section 3, that even a single-layered CNN for $A , B , C$ is sufficient for learning the operator. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The dec / rec module uses the filter matrices which are fixed beforehand, therefore, this part does not require any training. The model does not work for any arbitrary choice of fixed matrices $H , G$ . We show in Section 3.4 that for randomly selected matrices, the model does not learn, which validates that careful construction of filter matrices is necessary. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.4 Operators Properties ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            199,
+            361,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This section outlines definition of the integral kernels that are typically useful in an efficient compression of the operators through multiwavelets. We then discuss a fundamental property of the pseudo-differential operator. ",
+        "bbox": [
+            174,
+            224,
+            826,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 ([54]). Calder��n-Zygmund Operator. The integral operators that have kernel $K ( x , y )$ which is smooth away from the diagonal, and satisfy the following. ",
+        "bbox": [
+            171,
+            271,
+            823,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5154805ce185f2be69e120fde4518d4939588b2012f035e621587db46fa1f03.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle { | K ( x , y ) | \\le \\frac { 1 } { | x - y | } , } } \\\\ { \\displaystyle { | \\partial _ { x } ^ { M } K ( x , y ) | + | \\partial _ { y } ^ { M } K ( x , y ) | \\le \\frac { C _ { 0 } } { | x - y | ^ { M + 1 } } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            308,
+            651,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The smooth functions with decaying derivatives are gold to the multiwavelet transform. Note that, smoothness implies Taylor series expansion, and the multiwavelet transform with sufficiently large $k$ zeroes out the initial $k$ terms of the expansion due to vanishing moments property (5). This is how multiwavelet sparsifies the kernel (see Figure 1 where $K ( x , y )$ is smooth). Although, the definition of Calderón-Zygmund is simple (singularities only at the diagonal), but the multiwavelets are capable to compresses the kernel as long as the number of singularities are finite. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The next property, from [19], points out that with input/output being single-dimensional functions, for any pseudo-differential operator (with smooth coefficients), the singularity at the diagonal is also well-characterized. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Property 1. Smoothness of Pseudo-Differential Operator. For the integral kernel $K ( x , y )$ of $a$ pseudo-differential operator, $K ( x , y ) \\in C ^ { \\infty } \\forall x \\neq y$ , and for $x = y$ , $K ( x , y ) \\in C ^ { T - 1 }$ , where $T + 1$ is the highest derivative order in the given pseudo-differential equation. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The property 1 implies that, for the class of pseudo-differential operator, and any set of basis with the initial $J$ vanishing moments, the projection of kernel onto such bases will have the diagonal dominating the non-diagonal entries, exponentially, if $J > T - 1$ [19]. For the case of multiwavelet basis with $k$ OPs, $J = k$ (from eq. (5)). Therefore, $k > T - 1$ sparsifies the kernel projection onto multiwavelets, for a fixed number of bits precision $\\epsilon$ . We see the implication of the Property 1 on our proposed model in the Section 3.2. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            385,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the multiwavelet-based model (MWT) on several PDE datasets. We show that the proposed MWT model not only exhibits orders of magnitude higher accuracy when compared against the state-of-the-art (Sota) approaches but also works consistently well under different input conditions without parameter tuning. From a numerical perspective, we take the data as point-wise evaluations of the input and output functions. Specifically, we have the dataset $( a _ { i } , u _ { i } )$ with $a _ { i } = a ( x _ { i } ) , u _ { i } = u ( x _ { i } )$ for $x _ { 1 } , x _ { 2 } , \\dotsc , x _ { N } \\in D$ , where $x _ { i }$ are $M$ -point discretization of the domain $D$ . Unless stated otherwise, the training set is of size 1000 while test is of size 200. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model architectures: Unless otherwise stated, the NNs $A , B$ and $C$ in the proposed model (Figure 2) are chosen as a single-layered CNNs following a linear layer, while $\\bar { T }$ is taken as single $k \\times k$ linear layer. We choose $k = 4$ in all our experiments, and the OP basis as Legendre (Leg), Chebyshev (Chb) with uniform, non-uniform measure $\\mu _ { 0 }$ , respectively. The model in Figure 2 is treated as single layer, and for 1D equations, we cascade 2 multiwavelet layers, while for 2D dataset, we use a total 4 layers with $R e L U$ non-linearity. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/040fc20b86475ef5d4753e4ac6d5b2fbcd704c8d5beba8814de27e5d0d94966c.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Korteweg-de Vries (KdV) equation benchmarks for different input resolution s. Top: Our methods. Bottom: previous works of Neural operator. "
+        ],
+        "table_body": "<table><tr><td>Networks</td><td>s =64</td><td>s=128</td><td>s = 256</td><td>s = 512</td><td>s = 1024</td></tr><tr><td>MWT Leg MWT Chb</td><td>0.00338 0.00715</td><td>0.00375 0.00712</td><td>0.00418 0.00604</td><td>0.00393 0.00769</td><td>0.00389</td></tr><tr><td>FNO</td><td>0.0125</td><td>0.0124</td><td>0.0125</td><td>0.0122</td><td>0.00675 0.0126</td></tr><tr><td>MGNO</td><td>0.1296</td><td>0.1515</td><td>0.1355</td><td>0.1345</td><td>0.1363</td></tr><tr><td>LNO</td><td>0.0429</td><td>0.0557</td><td>0.0414</td><td>0.0425</td><td>0.0447</td></tr><tr><td>GNO</td><td>0.0789</td><td>0.0760</td><td>0.0695</td><td>0.0699</td><td>0.0721</td></tr></table>",
+        "bbox": [
+            183,
+            88,
+            820,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0004050902d1d4696836111b6830f046446812dc2ba692989a82d801aa436b5.jpg",
+        "image_caption": [
+            "Figure 3: The output of the KdV equation. (Left) An input $u _ { 0 } ( x )$ with $\\lambda = 0 . 0 2$ . (Right) The predicted output of the MWT Leg model learning the high fluctuations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            242,
+            813,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From a mathematical viewpoint, the dec and rec modules in Figure 2 transform only the multiscale and multiwavelet coefficients. However, the input and output to the model are point-wise function samples, i.e., $( a _ { i } , u _ { i } )$ . A remedy around this is to take the data sequence, and construct hypothetical functions $\\begin{array} { r } { f _ { a } = \\sum _ { i = 1 } ^ { N } a _ { i } \\phi _ { j i } ^ { n } } \\end{array}$ and $\\begin{array} { r } { f _ { u } = \\sum _ { i = 1 } ^ { N } u _ { i } \\phi _ { j i } ^ { n } } \\end{array}$ . Clearly, $f _ { a } , f _ { u }$ lives in $V _ { n } ^ { k }$ with $n = \\log _ { 2 } N$ . Now the model can be used with $s ^ { ( n ) } = a _ { i }$ and $U _ { s } ^ { ( n ) } = u _ { i }$ . Note that $f _ { a } , f _ { u }$ are not explicitly used, but only a matter of convention. ",
+        "bbox": [
+            173,
+            444,
+            826,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Benchmark models: We compare our MWT model using two different OP basis (Leg, Chb) with the most recent successful neural operators. Specifically, we consider the graph neural operator (GNO) [48], the multipole graph neural operator (MGNO) [49], the LNO which makes a low-rank $( r )$ representation of the operator kernel $K ( x , y )$ (also similar to unstacked DeepONet [50]), and the Fourier neural operator (FNO ) [47]. We experiment on three competent datasets setup by the work of FNO (Burgers’ equation (1-D), Darcy Flow (2-D), and Navier-Stokes equation (time-varying 2-D)). In addition, we also experiment with Korteweg-de Vries equation (1-D). For the 1-D cases, a modified FNO with careful parameter selection and removal of Batch-normalization layers results in a better performance compared with the original FNO, and we use it in our experiments. The MWT model demonstrates the highest accuracy in all the experiments. The MWT model also shows the ability to learn the function mapping through lower-resolution data, and able to generalize to higher resolutions. ",
+        "bbox": [
+            173,
+            541,
+            826,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All the models (including ours) are trained for a total of 500 epochs using Adam optimizer with an initial learning rate (LR) of 0.001. The LR decays after every 100 epochs with a factor of $\\gamma = 0 . 5$ The loss function is taken as relative $L 2$ error [47]. All of the experiments are performed on a single Nvidia V100 32 GB GPU, and the results are averaged over a total of 3 seeds. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 Korteweg-de Vries (KdV) Equation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            460,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Korteweg-de Vries (KdV) equation was first proposed by Boussinesq [16] and rediscovered by Korteweg and de Vries [23]. KdV is a 1-D non-linear PDE commonly used to describe the non-linear shallow water waves. For a given field $u ( x , t )$ , the dynamics takes the following form: ",
+        "bbox": [
+            176,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a69e8722de2bbad8509ce853949d457c78308594305c6da39e30381ad0a090f.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle { \\frac { \\partial u } { \\partial t } = - 0 . 5 u \\frac { \\partial u } { \\partial x } - \\frac { \\partial ^ { 3 } u } { \\partial x ^ { 3 } } , x \\in ( 0 , 1 ) , t \\in ( 0 , 1 ] } } \\\\ { \\displaystyle { u _ { 0 } ( x ) = u ( x , t = 0 ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            859,
+            658,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The task for the neural operator is to learn the mapping of the initial condition $u _ { 0 } ( x )$ to the solutions $u ( x , t = 1 )$ . We generate the initial condition in Gaussian random fields according to $u _ { 0 } \\sim$ $\\dot { \\mathcal { N } } ( 0 , 7 ^ { 4 } ( - \\Delta + 7 ^ { 2 } \\bar { I _ { ) } } ^ { - 2 . 5 } )$ with periodic boundary conditions. The equation is numerically solved using chebfun package [27] with a resolution $2 ^ { 1 0 }$ , and datasets with lower resolutions are obtained by sub-sampling the highest resolution data set. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Varying resolution: The experimental results of the KdV equation for different input resolutions $s$ are shown in Table1. We see that, compared to any of the benchmarks, our proposed MWT Leg exhibits the lowest relative error and is lowest nearly by an order of magnitude. Even in the case of the resolution of 64, the relative error is low, which means that a sparse data set with a coarse resolution of 64 is sufficient for the neural operator to learn the function mapping between infinite-dimensional spaces. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Varying fluctuations: We now vary the smoothness of the input function $u _ { 0 } ( x , 0 )$ by controlling the parameter $\\lambda$ , where low values of $\\lambda$ imply more frequent fluctuations and $\\lambda  0$ reaches the Brownian motion limit [30]. To isolate the importance of incorporating the multiwavelet transformation, we use the same convolution operation as in FNO, i.e., Fourier transform-based convolution with different modes $k _ { m }$ (only single-layer) for $A , B , C$ . We see in Figure 4 that MWT model consistently outperforms the recent baselines for all the values of $\\lambda$ . A sample input/output from test set is shown in the Figure 3. The FNO model with higher values of $k _ { m }$ has better performance due to more Fourier bases for representing the high-frequency signal, while MWT does better even with low modes in its $A , B , C$ CNNs, highlighting the importance of using wavelet-based filters in the signal processing. ",
+        "bbox": [
+            174,
+            257,
+            517,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/66c0995dded710f31f0f2976672ba887d6cdc8243cfded66fa80fa7a23a8cfa4.jpg",
+        "image_caption": [
+            "Figure 4: Comparing MWT by varying the degree of fluctuations $\\lambda$ in the input with resolution $s =$ 1024. For each convolution, we fix the number of Fourier bases as $k _ { m }$ . For FNO, the width is 64. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            532,
+            262,
+            818,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            478,
+            653,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 Theoretical Properties Validation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            444,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We test the ability of the proposed MWT model to capture the theoretical properties of the pseudodifferential operator in this Section. Towards that, we consider the Euler-Bernoulli equation [62] that models the vertical displacement of a finite length beam over time. A Fourier transform version of the beam equation with the constraint of both ends being clamped is as follows ",
+        "bbox": [
+            174,
+            532,
+            826,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d89e3b37c5986b1d56dbd168e8aa677c2c863822e6364198abc5ba4791a1709d.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle { \\frac { \\partial ^ { 4 } u } { \\partial x ^ { 4 } } } - \\omega ^ { 2 } u = f ( x ) , \\quad \\displaystyle { \\frac { \\partial u } { \\partial x } } \\Big \\vert _ { x = 0 } = 0 } } \\\\ { { u ( 0 ) = u ( 1 ) = 0 , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            594,
+            617,
+            647
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $u ( x )$ is the Fourier transform of the time-varying beam displacement, $\\omega$ is the frequency, $f ( x )$ is the applied force. The Euler-Bernoulli is a pseudo-differential equation with the maximum derivative order $T + 1 = 4$ . We take the task of learning the map from $f$ to $u$ . In Figure 5, we see that for $k \\geq 3$ , the models relative error across epochs is similar, however, they are different for $k < 3$ , which is in accordance with the Property 1. For $k < 3$ , the multiwavelets will not be able to annihilate the diagonal of the kernel which is $C ^ { T - 1 }$ , hence, sparsification cannot occur, and the model learns slow. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 Burgers’ Equation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            343,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The 1-D Burgers’ equation is a non-linear PDE occurring in various areas of applied mathematics. For a given field $u ( x , t )$ and diffusion coefficient $v$ , the 1-D Burgers’ equation reads: ",
+        "bbox": [
+            171,
+            790,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/302b3a40f1e2bda2540fd8a2c4bc43013618e0fa6ce7d44b80f5e932a2fe2d95.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle \\frac { \\partial u } { \\partial t } = - u \\frac { \\partial u } { \\partial x } + v \\frac { \\partial ^ { 2 } u } { \\partial x ^ { 2 } } , x \\in ( 0 , 2 \\pi ) , t \\in ( 0 , 1 ] } } \\\\ { { u _ { 0 } ( x ) = u ( x , t = 0 ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            825,
+            656,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The task for the neural operator is to learn the mapping of initial condition $u ( x , t = 0 )$ to the solutions at $= 1 \\ : u ( x , t = 1 )$ . To compare with many advanced neural operators under the same conditions, we use the Burgers’ data and the results that have been published in [47] and [49]. The initial condition is sampled as Gaussian random fields where $u _ { 0 } \\stackrel { . } { \\sim } \\mathcal { N } ( 0 , 5 ^ { 4 } ( - \\bar { \\Delta } + 5 ^ { 2 } I ) ^ { - 2 } )$ with periodic boundary conditions. $\\Delta$ is the Laplacian, meaning the initial conditions are sampled by sampling its first several coefficients from a Gaussian distribution. In the Burgers’ equation, $v$ is set to 0.1. The equation is solved with resolution $2 ^ { 1 3 }$ , and the data with lower resolutions are obtained by sub-sampling the highest resolution data set. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/707f946f0e821cdf1670b8c04c9b49009a3d2712bcc1403f17f483486149fe4e.jpg",
+        "image_caption": [
+            "Figure 5: Relative $L 2$ error vs epochs for MWT Leg with different number of OP basis $k = 1 , \\ldots , 6$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            488,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b31ea507ce568cca8fb98302ca37c0f3eee40e3502c6c92e3959fd7f3cb73bfd.jpg",
+        "image_caption": [
+            "Figure 6: Burgers’ Equation validation at various input resolution $s$ . Our methods: MWT Leg, Chb. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            94,
+            816,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c94667dbbc6874dd35668c161c6af01ef2dee1e8898c8b83c6e1d08a1b35349.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Benchmarks on Darcy Flow equation at various input resolution s. Top: Our methods. MWT Rnd instantiate random entries of the filter matrices in (6)-(9). Bottom: prior works on Neural operator. "
+        ],
+        "table_body": "<table><tr><td>Networks</td><td>s=32</td><td>s=64</td><td>s=128</td><td>s= 256</td><td>s=512</td></tr><tr><td>MWT Leg</td><td>0.0152</td><td>0.00899</td><td>0.00747</td><td>0.00722</td><td>0.00654</td></tr><tr><td>MWT Chb</td><td>0.0174</td><td>0.0108</td><td>0.00872</td><td>0.00892</td><td>0.00891</td></tr><tr><td>MWTRnd</td><td>0.2435</td><td>0.2434</td><td>0.2434</td><td>0.2431</td><td>0.2432</td></tr><tr><td>FNO</td><td>0.0177</td><td>0.0121</td><td>0.0111</td><td>0.0107</td><td>0.0106</td></tr><tr><td>MGNO</td><td>0.0501</td><td>0.0519</td><td>0.0547</td><td>0.0542</td><td>-</td></tr><tr><td>LNO</td><td>0.0524</td><td>0.0457</td><td>0.0453</td><td>0.0428</td><td>=</td></tr></table>",
+        "bbox": [
+            192,
+            339,
+            803,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            500,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results of the experiments on Burgers’ equation for different resolutions are shown in Figure 6. Compared to any of the benchmarks, our MWT Leg obtains the lowest relative error, which is an order of magnitude lower than the state-of-the-art. It’s worth noting that even in the case of low resolution, MWT Leg still maintains a very low error rate, which shows its potential for learning the function mapping through low-resolution data, that is, the ability to map between infinite-dimensional spaces by learning a limited finite-dimensional spaces mapping. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4 Darcy Flow ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            689,
+            294,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Darcy flow formulated by Darcy[22] is one of the basic relationships of hydrogeology, describing the flow of a fluid through a porous medium. We experiment on the steady-state of the 2-d Darcy flow equation on the unit box, where it takes the following form: ",
+        "bbox": [
+            174,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f8c63341750553dd6381ea80f78e65562d9131c7afeb17ea74873e328697790.jpg",
+        "text": "$$\n\\begin{array} { r } { \\nabla \\cdot ( a ( x ) \\nabla u ( x ) ) = f ( x ) , \\quad x \\in ( 0 , 1 ) ^ { 2 } } \\\\ { u ( x ) = 0 , \\qquad x \\in \\partial ( 0 , 1 ) ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            761,
+            635,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We set the experiments to learn the operator mapping the coefficient $a ( x )$ to the solution $u ( x )$ . The coefficients are generated according to $a \\sim \\mathcal { N } ( 0 , ( - \\Delta + 3 ^ { 2 } I ) ^ { - 2 } )$ , where $\\Delta$ is the Laplacian with zero Neumann boundary conditions. The threshold of $a ( x )$ is set to achieve ellipticity. The solutions $u ( x )$ are obtained by using a 2nd-order finite difference scheme on a $5 1 2 \\times 5 1 2$ grid. Data sets of lower resolution are sub-sampled from the original data set. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results of the experiments on Darcy Flow for different resolutions are shown in Table2. MWT Leg again obtains the lowest relative error compared to other neural operators at various resolutions. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also perform an additional experiment, in which the multiwavelet filters $H ^ { ( i ) } , G ^ { ( i ) } , i = 0 , 1$ are replaced with random values (properly normalized). We see in Table 2, that MWT Rnd does not learn the operator map, in fact, its performance is worse than all the models. This signifies the importance of the careful choice of the filter matrices. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3.5 Additional Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            380,
+            178
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Full results for these experiments are provided in the supplementary materials. ",
+        "bbox": [
+            173,
+            188,
+            686,
+            203
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Navier Stokes Equation: The Navier-Stokes (NS) are 2d time-varying PDEs modeling the viscous, incompressible fluids. The proposed MWT model does a 2d multiwavelet transform for the velocity $u$ , while uses a single-layered 3d convolution for $A , B$ and $C$ to learn dependencies across space-time. We have observed that the proposed MWT Leg is in par with the Sota on the NS equations. ",
+        "bbox": [
+            174,
+            209,
+            826,
+            265
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prediction at high resolution: We show that MWT model trained at lower resolutions for various datasets (for example, training with $s = 2 5 6$ for Burgers) can predict the output at finer resolutions $s = 2 0 4 8$ , with relative error of 0.0226, thus eliminating the need for expensive sampling. The training and testing with $s = 2 0 4 8$ yields a relative error of 0.00189. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Train/evaluation with different sampling rules: We study the operator learning behavior when the training and evaluation datasets are obtained using the random function from different generating rules. The training is done with squared exponential kernel but evaluation is done on different generating rule [30] with controllable parameter $\\lambda$ . ",
+        "bbox": [
+            174,
+            333,
+            825,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            299,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We address the problem of data-driven learning of the operator that maps between two function spaces. Motivated from the fundamental properties of the integral kernel, we found that multiwavelets constitute a natural basis to represent the kernel sparsely. After generalizing the multiwavelets to work with arbitrary measures, we proposed a series of models to learn the integral operator. This work opens up new research directions and possibilities toward designing efficient Neural operators utilizing properties of the kernels, and the suitable basis. We anticipate that the study of this problem will solve many engineering and biological problems such as aircraft wing design, complex fluids dynamics, metamaterials design, cyber-physical systems, neuron-neuron interactions that are modeled by complex PDEs. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            330,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We are thankful to the anonymous reviewers for providing their valuable feedback which improved the manuscript. We would also like to thank Radu Balan for his valuable feedback. We gratefully acknowledge the support by the National Science Foundation Career award under Grant No. CPS/CNS-1453860, the NSF award under Grant CCF-1837131, MCB-1936775, CNS-1932620, the U.S. Army Research Office (ARO) under Grant No. W911NF-17-1-0076, the Okawa Foundation award, and the Defense Advanced Research Projects Agency (DARPA) Young Faculty Award and DARPA Director Award under Grant No. N66001-17-1-4044, an Intel faculty award and a Northrop Grumman grant. A part of this work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number ACI-1548562. The views, opinions, and/or findings contained in this article are those of the authors and should not be interpreted as representing the official views or policies, either expressed or implied by the Defense Advanced Research Projects Agency, the Army Research Office, the Department of Defense or the National Science Foundation. ",
+        "bbox": [
+            173,
+            614,
+            826,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Abramowitz and I.A. Stegun. Handbook of Mathematical Functions: With Formulas, Graphs, and Mathematical Tables. Applied mathematics series. Dover Publications, 1965. ISBN 9780486612720.   \n[2] Jonas Adler and Ozan Öktem. Solving ill-posed inverse problems using iterative deep neural networks. Inverse Problems, 33(12), Nov 2017. ISSN 1361-6420. doi: 10.1088/1361-6420/ aa9581. URL http://dx.doi.org/10.1088/1361-6420/aa9581.   \n[3] B. Alpert, G. Beylkin, R. Coifman, and V. Rokhlin. Wavelet-like bases for the fast solution of second-kind integral equations. SIAM Journal on Scientific Computing, 14(1):159–184, 1993. doi: 10.1137/0914010.   \n[4] B. Alpert, G. Beylkin, D. Gines, and L. Vozovoi. Adaptive solution of partial differential equations in multiwavelet bases. Journal of Computational Physics, 182(1):149–190, 2002. ISSN 0021-9991.   \n[5] Bradley K. Alpert. A class of bases in $L ^ { 2 }$ for the sparse representation of integral operators. SIAM Journal on Mathematical Analysis, 24(1):246–262, 1993. doi: 10.1137/0524016.   \n[6] Bradley K. Alpert and Vladimir Rokhlin. A fast algorithm for the evaluation of legendre expansions. SIAM Journal on Scientific and Statistical Computing, 12(1):158–179, 1991. doi: 10.1137/0912009.   \n[7] Kevin Amaratunga and John Williams. Wavelet based green’s function approach to 2d pdes. Engineering Computations, 10, 07 2001. doi: 10.1108/eb023913.   \n[8] Radu Balan, Bernhard G. Bodmann, Peter G. Casazza, and Dan Edidin. Painless reconstruction from magnitudes of frame coefficients. Journal of Fourier Analysis and Applications, 16: 488–501, 2009.   \n[9] J.J. Benedetto. Wavelets: Mathematics and Applications. Studies in Advanced Mathematics. Taylor & Francis, 1993. ISBN 9780849382710.   \n[10] G. Beylkin. On the representation of operators in bases of compactly supported wavelets. SIAM Journal on Numerical Analysis, 29(6):1716–1740, 1992. doi: 10.1137/0729097.   \n[11] G. Beylkin, R. Coifman, and V. Rokhlin. Fast wavelet transforms and numerical algorithms i. Communications on Pure and Applied Mathematics, 44(2):141–183, 1991. doi: https: //doi.org/10.1002/cpa.3160440202.   \n[12] Gregory Beylkłn and James M. Keiser. An adaptive pseudo-wavelet approach for solving nonlinear partial differential equations. In Multiscale Wavelet Methods for Partial Differential Equations, volume 6 of Wavelet Analysis and Its Applications, pages 137–197. Academic Press, 1997.   \n[13] Saakaar Bhatnagar, Yaser Afshar, Shaowu Pan, Karthik Duraisamy, and Shailendra Kaushik. Prediction of aerodynamic flow fields using convolutional neural networks. Computational Mechanics, 64(2):525–545, Jun 2019. ISSN 1432-0924. doi: 10.1007/s00466-019-01740-0.   \n[14] Kaushik Bhattacharya, Bamdad Hosseini, Nikola B. Kovachki, and Andrew M. Stuart. Model reduction and neural networks for parametric pdes, 2020.   \n[15] Nicolas Boulle, Christopher J. Earls, and Alex Townsend. Data-driven discovery of physical laws with human-understandable deep learning, 2021.   \n[16] Joseph Boussinesq. Essai sur la théorie des eaux courantes. Impr. nationale, 1877.   \n[17] R. Y. Chang and M. L. Wang. Shifted legendre direct method for variational problems. Journal of Optimization Theory and Applications, 39(2):299–307, Feb 1983. ISSN 1573-2878. doi: 10.1007/BF00934535.   \n[18] Zhengdao Chen, Jianyu Zhang, Martin Arjovsky, and Léon Bottou. Symplectic recurrent neural networks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=BkgYPREtPr.   \n[19] Kenneth C. Chou and Gary S. Guthart. Representation of green’s function integral operators using wavelet transforms. Journal of Vibration and Control, 6(1):19–48, 2000. doi: 10.1177/ 107754630000600102.   \n[20] N.M. Chuong. Pseudodifferential Operators and Wavelets over Real and $p$ -adic Fields. Springer International Publishing, 2018. ISBN 9783319774732.   \n[21] M. Cotronei, L.B. Montefusco, and L. Puccio. Multiwavelet analysis and signal processing. IEEE Transactions on Circuits and Systems II: Analog and Digital Signal Processing, 45(8): 970–987, 1998.   \n[22] Henry Darcy. Les fontaines publiques de la ville de Dijon: exposition et application... Victor Dalmont, 1856.   \n[23] Olivier Darrigol. Worlds of flow: A history of hydrodynamics from the Bernoullis to Prandtl. Oxford University Press, 2005.   \n[24] Ingrid Daubechies. Orthonormal bases of compactly supported wavelets. Communications on Pure and Applied Mathematics, 41(7):909–996, 1988. doi: https://doi.org/10.1002/cpa. 3160410705.   \n[25] Ingrid Daubechies. Ten Lectures on Wavelets. Society for Industrial and Applied Mathematics, 1992. doi: 10.1137/1.9781611970104.   \n[26] D. Deng, Y. Meyer, and Y. Han. Harmonic Analysis on Spaces of Homogeneous Type. Lecture Notes in Mathematics. Springer Berlin Heidelberg, 2008. ISBN 9783540887447.   \n[27] T. A Driscoll, N. Hale, and L. N. Trefethen. Chebfun Guide. Pafnuty Publications, 2014.   \n[28] Yuwei Fan, Jordi Feliu-Faba, Lin Lin, Lexing Ying, and Leonardo Zepeda-Nunez. A multiscale neural network based on hierarchical nested bases, 2019.   \n[29] Jordi Feliu-Fabà, Yuwei Fan, and Lexing Ying. Meta-learning pseudo-differential operators with deep neural networks. Journal of Computational Physics, 408:109309, May 2020. ISSN 0021-9991. doi: 10.1016/j.jcp.2020.109309.   \n[30] Silviu-Ioan Filip, Aurya Javeed, and Lloyd Trefethen. Smooth random functions, random odes, and gaussian processes. SIAM Review, 61:185–205, 01 2019. doi: 10.1137/17M1161853.   \n[31] Daniel Greenfeld, Meirav Galun, Ron Kimmel, Irad Yavneh, and Ronen Basri. Learning to optimize multigrid pde solvers, 2019.   \n[32] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Ré. Hippo: Recurrent memory with optimal polynomial projections. In Advances in Neural Information Processing Systems, volume 33, pages 1474–1487, 2020.   \n[33] Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, page 481–490. Association for Computing Machinery, 2016.   \n[34] Mustafa Hajij, Ghada Zamzmi, Matthew Dawson, and Greg Muller. Algebraically-informed deep networks (aidn): A deep learning approach to represent algebraic structures, 2021.   \n[35] M.H. Heydari, M.R. Hooshmandasl, and F. Mohammadi. Legendre wavelets method for solving fractional partial differential equations with dirichlet boundary conditions. Applied Mathematics and Computation, 234:267–276, 2014. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc. 2014.02.047.   \n[36] Chyi Hwang and Yen-Ping Shih. Solution of integral equations via laguerre polynomials. Computers & Electrical Engineering, 9(3):123–129, 1982. ISSN 0045-7906. doi: https: //doi.org/10.1016/0045-7906(82)90018-0.   \n[37] Ameya D. Jagtap, Yeonjong Shin, Kenji Kawaguchi, and George Em Karniadakis. Deep kronecker neural networks: A general framework for neural networks with adaptive activation functions, 2021.   \n[38] M. Tavassoli Kajani, A. Hadi Vencheh, and M. Ghasemi. The chebyshev wavelets operational matrix of integration and product operation matrix. International Journal of Computer Mathematics, 86(7):1118–1125, 2009. doi: 10.1080/00207160701736236.   \n[39] F. Khellat and S.A. Yousefi. The linear legendre mother wavelets operational matrix of integration and its application. Journal of the Franklin Institute, 343(2):181–190, 2006. ISSN 0016-0032. doi: https://doi.org/10.1016/j.jfranklin.2005.11.002.   \n[40] Yuehaw Khoo, Jianfeng Lu, and Lexing Ying. Solving parametric pde problems with artificial neural networks. European Journal of Applied Mathematics, 32(3):421–435, Jul 2020. ISSN 1469-4425.   \n[41] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series, 2020.   \n[42] Dmitrii Kochkov, Jamie A. Smith, Ayya Alieva, Qing Wang, Michael P. Brenner, and Stephan Hoyer. Machine learning–accelerated computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21), 2021. ISSN 0027-8424. doi: 10.1073/pnas.2101784118.   \n[43] Vasil Kolev, Todor Cooklev, and Fritz Keinert. Design of a simple orthogonal multiwavelet filter by matrix spectral factorization. Circuits, Systems, and Signal Processing, 39(4):2006–2041, Aug 2019.   \n[44] Samuel Lanthaler, Siddhartha Mishra, and George Em Karniadakis. Error estimates for deeponets: A deep learning framework in infinite dimensions, 2021.   \n[45] Yuanlu LI. Solving a nonlinear fractional differential equation using chebyshev wavelets. Communications in Nonlinear Science and Numerical Simulation, 15(9):2284–2292, 2010. ISSN 1007-5704. doi: https://doi.org/10.1016/j.cnsns.2009.09.020.   \n[46] Yuanlu Li and Weiwei Zhao. Haar wavelet operational matrix of fractional order integration and its applications in solving the fractional order differential equations. Applied Mathematics and Computation, 216(8):2276–2285, 2010. ISSN 0096-3003. doi: https://doi.org/10.1016/j. amc.2010.03.063.   \n[47] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Fourier neural operator for parametric partial differential equations, 2020.   \n[48] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Neural operator: Graph kernel network for partial differential equations, 2020.   \n[49] Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Andrew Stuart, Kaushik Bhattacharya, and Anima Anandkumar. Multipole graph neural operator for parametric partial differential equations. In Advances in Neural Information Processing Systems, volume 33, pages 6755–6766, 2020.   \n[50] Lu Lu, Pengzhan Jin, and George Em Karniadakis. Deeponet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators, 2020.   \n[51] Lu Lu, Pengzhan Jin, Guofei Pang, Zhongqiang Zhang, and George Em Karniadakis. Learning nonlinear operators via deeponet based on the universal approximation theorem of operators. Nature Machine Intelligence, 3(3):218–229, Mar 2021. ISSN 2522-5839.   \n[52] Ryan McKeown, Rodolfo Ostilla-Mónico, Alain Pumir, Michael P. Brenner, and Shmuel M. Rubinstein. Turbulence generation through an iterative cascade of the elliptical instability. Science Advances, 6(9), 2020. doi: 10.1126/sciadv.aaz2717.   \n[53] Y. Meyer and D.H. Salinger. Wavelets and Operators: Volume 1. Cambridge Studies in Advanced Mathematics. Cambridge University Press, 1992. ISBN 9780521458696.   \n[54] Y. Meyer, R. Coifman, and D. Salinger. Wavelets: Calderón-Zygmund and Multilinear Operators. Cambridge Studies in Advanced Mathematics. Cambridge University Press, 1997. ISBN 9780521420013.   \n[55] Guillaume Ovarlez, Anh Vu Nguyen Le, Wilbert J. Smit, Abdoulaye Fall, Romain Mari, Guillaume Chatté, and Annie Colin. Density waves in shear-thickening suspensions. Science Advances, 6(16), 2020. doi: 10.1126/sciadv.aay5589.   \n[56] Ravi G. Patel, Nathaniel A. Trask, Mitchell A. Wood, and Eric C. Cyr. A physics-informed operator regression framework for extracting data-driven continuum models. Computer Methods in Applied Mechanics and Engineering, 373:113500, 2021. ISSN 0045-7825. doi: https: //doi.org/10.1016/j.cma.2020.113500.   \n[57] M. Raissi, P. Perdikaris, and G.E. Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial ",
+        "bbox": [
+            171,
+            70,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            39,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            59,
+            828,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "differential equations. Journal of Computational Physics, 378:686–707, 2019. ISSN 0021- ",
+        "bbox": [
+            202,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "9991.   \n[58] C.E. Rasmussen and C.K.I. Williams. Gaussian Processes for Machine Learning. Adaptative computation and machine learning series. University Press Group Limited, 2006.   \n[59] Mohsen Razzaghi and Samira Yousefi. The legendre wavelets operational matrix of integration. International Journal of Systems Science, 32:495–502, 04 2001. doi: 10.1080/00207720120227.   \n[60] M. F. Shlesinger, B. J. West, and J. Klafter. Lévy dynamics of enhanced diffusion: Application to turbulence. Phys. Rev. Lett., 58:1100–1103, Mar 1987. doi: 10.1103/PhysRevLett.58.1100.   \n[61] B. W. Silverman, J. C. Vassilicos, and Nick Kingsbury. Image processing with complex wavelets. Philosophical Transactions of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 357(1760):2543–2560, 1999. doi: 10.1098/rsta.1999.0447.   \n[62] S. Timoshenko. History of Strength of Materials: With a Brief Account of the History of Theory of Elasticity and Theory of Structures. Dover Civil and Mechanical Engineering Series. Dover Publications, 1983. ISBN 9780486611877.   \n[63] J. Towns, T. Cockerill, M. Dahan, I. Foster, K. Gaither, A. Grimshaw, V. Hazlewood, S. Lathrop, D. Lifka, G. D. Peterson, R. Roskies, J. R. Scott, and N. Wilkins-Diehr. Xsede: Accelerating scientific discovery. Computing in Science & Engineering, 16(5):62–74, Sept.-Oct. 2014. ISSN 1521-9615. doi: 10.1109/MCSE.2014.80. URL doi.ieeecomputersociety.org/10.1109/ MCSE.2014.80.   \n[64] Lifeng Wang, Yunpeng Ma, and Zhijun Meng. Haar wavelet method for solving fractional partial differential equations numerically. Applied Mathematics and Computation, 227:66–76, 2014. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc.2013.11.004.   \n[65] Sifan Wang, Hanwen Wang, and Paris Perdikaris. Learning the solution operator of parametric partial differential equations with physics-informed deeponets, 2021.   \n[66] Yanxin Wang and Qibin Fan. The second kind chebyshev wavelet method for solving fractional differential equations. Applied Mathematics and Computation, 218(17):8592–8601, 2012. ISSN 0096-3003. doi: https://doi.org/10.1016/j.amc.2012.02.022.   \n[67] Shiying Xiong, Xingzhe He, Yunjin Tong, and Bo Zhu. Neural vortex method: from finite lagrangian particles to infinite dimensional eulerian dynamics, 2020.   \n[68] Yuankun Xue and Paul Bogdan. Constructing compact causal mathematical models for complex dynamics. In 2017 ACM/IEEE 8th International Conference on Cyber-Physical Systems (ICCPS), pages 97–108, April 2017.   \n[69] Li Zhu and Yanxin Wang. Solving fractional partial differential equations by using the second chebyshev wavelet operational matrix method. Nonlinear Dynamics, 89(3):1915–1925, Aug 2017. ISSN 1573-269X. doi: 10.1007/s11071-017-3561-7.   \n[70] Li Zhu and Yanxin Wang. Solving fractional partial differential equations by using the second chebyshev wavelet operational matrix method. Nonlinear Dynamics, 89(3):1915–1925, Aug 2017. ISSN 1573-269X. doi: 10.1007/s11071-017-3561-7.   \n[71] Yinhao Zhu and Nicholas Zabaras. Bayesian deep convolutional encoder–decoder networks for surrogate modeling and uncertainty quantification. Journal of Computational Physics, 366: 415–447, Aug 2018. ISSN 0021-9991. ",
+        "bbox": [
+            171,
+            99,
+            828,
+            727
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] For example, see Table 1 2, Figure 6 for benchmarks on the datasets. Also, see Figure 3 for robustness plot, and Figure 5 for theoretical insights for pseudo-differential operators.   \n(b) Did you describe the limitations of your work? [Yes] We discuss in details the possible numerical issues that can occur in estimating the filter matrices ${ \\cal H } ^ { ( 0 ) } , { \\cal H } ^ { ( 1 ) } , { \\cal G } ^ { \\bar { ( 0 ) } } , { \\cal G } ^ { ( 1 ) }$ for large values of $k$ . The issue is not related to the mathematics involved but due to the nature of floating-point precision. We discuss this in details in the supplementary materials.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            311,
+            493,
+            325
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] Please refer to Section 2.2, where we list all the necessary derived results, while we have referred the reader (at appropriate places) to the supplementary materials for the complete details.   \n(b) Did you include complete proofs of all theoretical results? [Yes] We provide detailed derivations of all the measure dependent filter matrices ${ \\cal H } ^ { ( 0 ) } , { \\cal H } ^ { ( 1 ) } , { \\cal G } ^ { ( \\bar { 0 } ) } , { \\cal G } ^ { ( 1 ) }$ and also the correction terms $\\Sigma ^ { ( 0 ) } , \\Sigma ^ { ( 1 ) }$ in the supplementary materials. ",
+        "bbox": [
+            238,
+            330,
+            825,
+            419
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            422,
+            393,
+            436
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code is uploaded with the supplementary materials.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Please refer to Section 3 where we list all of the details regarding training and model architectures.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All the results included in the paper are averaged over a total of 3 seeds. We have also mentioned the same in Section 3.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All of the experiments were performed on a single Nvidia V100 32 GB GPU, please refer to Section 3. ",
+        "bbox": [
+            238,
+            440,
+            825,
+            613
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            617,
+            823,
+            632
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] A part of the datasets are taken from the FNO work [47], while some are generated using the scripts provided by the same authors. We have properly cited the work in Section 3 Benchmark models.   \n(b) Did you mention the license of the assets? [N/A] A part of the code and datasets ([47]) used by us are openly available with no license restriction, to the best of our knowledge.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] The code and the dataset is openly available.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] All the datasets are synthetically generated. ",
+        "bbox": [
+            238,
+            636,
+            825,
+            795
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            800,
+            705,
+            814
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            818,
+            825,
+            906
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SkxxIs0qY7/SkxxIs0qY7.md

@@ -0,0 +1,346 @@
+# COT: COOPERATIVE TRAINING FOR GENERATIVEMODELING OF DISCRETE DATA
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose Cooperative Training (CoT) for training generative models that measure a tractable density for discrete data. CoT coordinately trains a generator $G$ and an auxiliary predictive mediator $M$ . The training target of $M$ is to estimate a mixture density of the learned distribution $G$ and the target distribution $P$ , and that of $G$ is to minimize the Jensen-Shannon divergence estimated through $M$ . CoT achieves independent success without the necessity of pre-training via Maximum Likelihood Estimation or involving high-variance algorithms like REINFORCE. This low-variance algorithm is theoretically proved to be superior for both sample generation and likelihood prediction. We also theoretically and empirically show the superiority of CoT over most previous algorithms in terms of generative quality and diversity, predictive generalization ability and computational cost.
+
+# 1 INTRODUCTION
+
+Generative modeling is essential in many scenarios, including continuous data modeling (e.g. image generation (Goodfellow et al., 2014; Arjovsky et al., 2017), stylization (Ulyanov et al., 2016), semisupervised classification (Radford et al., 2015)) and sequential discrete data modeling (e.g. neural text generation (Bahdanau et al., 2014; Yu et al., 2017; Lu et al., 2018)).
+
+For discrete data with tractable density like natural language, generative models are predominantly optimized through Maximum Likelihood Estimation (MLE), inevitably introducing exposure bias (Ranzato et al., 2015), which results in that given a finite set of observations, the optimal parameters of the model trained via MLE do not correspond to the ones maximizing the generative quality. Specifically, the model is trained on the data distribution of inputs and tested on a different distribution of inputs, namely, the learned distribution. This discrepancy implies that in the training stage, the model is never exposed to its own errors and thus in the test stage, the errors made along the way will quickly accumulate.
+
+On the other hand, for general generative modeling tasks, an effective framework, named Generative Adversarial Network (GAN) (Goodfellow et al., 2014), was proposed to train an implicit density model for continuous data. GAN introduces a discriminator $D _ { \phi }$ parametrized by $\phi$ to distinguish the generated samples from the real ones. As is proved in (Goodfellow et al., 2014), GAN essentially optimizes an approximately estimated Jensen-Shannon divergence (JSD) between the currently learned distribution and the target distribution. GAN shows promising results in many unsupervised and semi-supervised learning tasks. The success of GAN results in the naissance of a new paradigm of deep generative models, i.e. adversarial networks.
+
+However, since the gradient computation requires backpropagation through the generator’s output, GAN can only model the distribution of continuous variables, making it non-applicable for generating discrete sequences like natural language. Researchers then proposed Sequence Generative Adversarial Network (SeqGAN) (Yu et al., 2017), which uses model-free policy gradient algorithm to optimize the original GAN objective. With SeqGAN, the expected JSD between current and target discrete data distribution is minimized if the training is perfect. SeqGAN shows observable improvements in many tasks. Since then, many variants of SeqGAN have been proposed to improve its performance. Nonetheless, SeqGAN is not an ideal algorithm for this problem, and current algorithms based on it cannot show stable, reliable and observable improvements that covers all scenarios, according to a previous survey (Lu et al., 2018). The detailed reason will be discussed in detail in Section 2.
+
+In this paper, we propose Cooperative Training (CoT), a novel, low-variance, bias-free algorithm for training likelihood-based generative models on discrete data by directly optimizing a wellestimated Jensen-Shannon divergence. CoT coordinately trains a generative module $G$ , and an auxiliary predictive module $M$ , called mediator, for guiding $G$ in a cooperative fashion. For theoretical soundness, we derive the proposed algorithm directly from the definition of JSD. We further empirically and theoretically demonstrate the superiority of our algorithm over many strong baselines in terms of generative performance, generalization ability and computational performance in both synthetic and real-world scenarios.
+
+# 2 BACKGROUND
+
+Notations. $P$ denotes the target data distribution. $\theta$ denotes the parameters of the generative module $G$ . $\phi$ denotes the parameters of the auxiliary predictive mediator module $M$ . Any symbol with subscript $g$ and $m$ stands for that of the generator and mediator, respectively. $s$ stands for a complete sample from the training dataset or a generated complete sequence, depending on the specific context. $s _ { t }$ means the $t$ -length prefix of the original sequence, i.e. an incomplete sequence of length $t$ . $x$ denotes a token, and $x _ { t }$ stands for a token that appears in the $t { \cdot }$ -th place of a sequence. Thus $s _ { t } = [ x _ { 0 } , x _ { 1 } , x _ { 2 } , \ldots , x _ { t - 1 } ]$ while the initial case $s _ { 0 }$ is $\varnothing$ .
+
+# 2.1 MAXIMUM LIKELIHOOD ESTIMATION
+
+Maximum likelihood estimation is equivalent to minimizing the KL divergence using the samples from the real distribution:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { s \sim p _ { \mathrm { d a t a } } } \left[ - \log G _ { \theta } ( s ) \right] ,
+$$
+
+where $G _ { \theta } ( s )$ is the estimated probability of $s$ by $G _ { \theta }$ and $p _ { \mathrm { d a t a } }$ is the underlying real distribution.
+
+Limitations of MLE. MLE is essentially equivalent to optimizing a directed Kullback–Leibler (KL) divergence between the target distribution $P$ and the currently learned distribution $G$ , denoted as $K L ( P \| G )$ . However, since KL divergence is asymmetric, given finite observations this target is actually not ideal. As stated in (Arjovsky & Bottou, 2017), MLE tries to minimize
+
+$$
+K L ( P \| G ) = \sum _ { s } P ( s ) \log { \frac { P ( s ) } { G ( s ) } } .
+$$
+
+• When $P ( s ) > 0$ and $G ( s ) \to 0$ , the KL divergence grows to infinity, which means MLE assigns an extremely high cost to the “mode dropping” scenarios, where the generator fails to cover some parts of the data. When $G ( s ) > 0$ and $P ( s ) \to 0$ , the KL divergence shrinks to 0, which means MLE assigns an extremely low cost to the scenarios, where the model generates some samples that do not locate on the data distribution.
+
+Likewise, optimizing $K L ( G \| P )$ will lead to exactly the reversed problems of the two situations. An ideal solution is to optimize a symmetrized and smoothed version of KL divergence, i.e. the Jensen-Shannon divergence (JSD), which is defined as
+
+$$
+J S D ( P \| G ) = \frac { 1 } { 2 } \big ( K L ( P \| M ) + K L ( G \| M ) \big ) ,
+$$
+
+where $M = { \textstyle \frac { 1 } { 2 } } ( P + G )$ . However, directly optimizing JSD is conventionally considered as an intractable problem. JSD cannot be directly evaluated and optimized since the equally interpolated distribution $M$ is usually considered to be unconstructable, as we only have access to the learned model $G$ instead of $P$ .
+
+# 2.2 SEQUENCE GENERATIVE ADVERSARIAL NETWORK
+
+SeqGAN incorporates two modules, i.e. the generator and discriminator, parametrized by $\theta$ and $\phi$ respectively, as in the settings of GAN. By alternatively training these two modules, SeqGAN optimizes such an adversarial target:
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \phi } \mathbb { E } _ { s \sim p _ { \mathrm { d a t a } } } \left[ \log ( D _ { \phi } ( s ) ) \right] + \mathbb { E } _ { s \sim G _ { \theta } } \left[ \log ( 1 - D _ { \phi } ( s ) ) \right] .
+$$
+
+# Algorithm 1 Cooperative Training
+
+Require: Generator $G _ { \theta }$ ; mediator $M _ { \phi }$ ; samples from real data distribution $P$ ; hyper-parameter $N _ { m }$ .   
+1: Initialize $G _ { \theta }$ , $M _ { \phi }$ with random weights $\theta , \phi$ .   
+2: repeat   
+3: for $N _ { m }$ steps do   
+4: Collect two equal-sized mini-batch of samples $\{ s _ { g } \}$ and $\{ s _ { p } \}$ from $G _ { \theta }$ and $P$ , respectively   
+5: Mix $\{ s _ { g } \}$ and $\{ s _ { p } \}$ as $\{ s \}$   
+6: Update mediator $M _ { \phi }$ with $\{ s \}$ via Eq. (9)   
+7: end for   
+8: Generate a mini-batch of sequences $\{ s \} \sim G _ { \theta }$   
+9: Update generator $G _ { \theta }$ with $\{ s \}$ via Eq. (13)   
+10: until CoT converges
+
+The objectives of generator $G _ { \theta }$ and discriminator $D _ { \phi }$ in SeqGAN can be formulated as
+
+$$
+\mathrm { G e n e r a t o r : \quad } \operatorname* { m i n } _ { \theta } - \mathbb { E } _ { s \sim G _ { \theta } } \Big [ \sum _ { t = 1 } ^ { n } Q _ { t } ( s _ { t } , x _ { t } ) \cdot \log G _ { \theta } ( x _ { t } | s _ { t } ) \Big ]
+$$
+
+$$
+\mathrm { i n a t o r : } \quad \operatorname* { m a x } _ { \phi } \mathbb { E } _ { s \sim p _ { \mathrm { d a t a } } } \left[ \log ( D _ { \phi } ( s ) ) \right] + \mathbb { E } _ { s \sim G _ { \theta } } \left[ \log ( 1 - D _ { \phi } ( s ) ) \right] ,
+$$
+
+where $s \sim G _ { \boldsymbol \theta } = [ x _ { 1 } , . . . , x _ { n } ]$ denotes a complete sequence sampled from the generator and the action value $Q _ { t } ( s _ { t } , x _ { t } ) \stackrel { - } { = } \mathbb { E } _ { s \sim G _ { \theta } ( \cdot | s _ { t + 1 } ) } \left[ D _ { \phi } ( s ) \right]$ is the expectation of the discriminator’s evaluation on the completed sequences sampled from the prefix $\boldsymbol { s } _ { t + 1 } = \left[ \boldsymbol { s } _ { t } , \boldsymbol { x } _ { t } \right]$ , which can be approximated via Monte Carlo search.
+
+Limitations of SeqGAN & its Variants. First, SeqGAN is an algorithm of high variance, which relies on pre-training via Maximum Likelihood Estimation as a variance reduction procedure. Besides, during the adversarial epochs, even if with variance reduction techniques such as Actor-Critic methods (Sutton, 1984), the fact that SeqGAN is essentially based on model-free reinforcement learning makes it a non-trivial problem for SeqGAN to converge well. As a result, SeqGAN usually gets stuck in some fake local optimals. Specifically, although the discriminator can distinguish the samples from the generator easily, it is not able to effectively guide the generator because of the vanishing gradient, as is discussed in a recent survey (Lu et al., 2018). Although this problem can be alleviated by reshaping the reward signals based on the relative rankings of the outputs in a mini-batch (Lin et al., 2017; Guo et al., 2017), they are more technical workarounds than essential solutions.
+
+Second, SeqGAN trained via REINFORCE (Williams, 1992) suffers from the “mode collapse” problem, which is similar to the original GAN. That is to say, the learned distribution “collapses” to the other side of KL divergence, i.e. $K L ( G \| P )$ , which leads to the loss of diversity of generated samples. In other words, SeqGAN trains the model for better generative quality at the cost of diversity.
+
+# 3 COOPERATIVE TRAINING
+
+# 3.1 MOTIVATION
+
+To be consistent with the goal that the target distribution should be well-estimated in both quality and diversity senses, an ideal algorithm for such models should be able to optimize a symmetric divergence or distance.
+
+For sequential discrete data modeling, since the data distribution is decomposed into a sequential product of finite-dimension multinomial distributions (always based on the softmax form), the failures of effectively optimizing JSD when the generated and real data distributions are distant, as discussed in (Arjovsky et al., 2017), will not appear. As such, to optimize JSD is feasible. However, to our knowledge, no previous algorithms provide a direct, low-variance optimization of JSD. In this paper, we propose Cooperative Training (CoT), as shown in Algorithm 1, to directly optimize a well-estimated unbiased JSD for training such models.
+
+# 3.2 ALGORITHM DERIVATION
+
+Each iteration of Cooperative Training mainly consists of two parts. The first part is to train a mediator $M _ { \phi }$ , which is a density function that estimates a mixture distribution of the learned generative distribution $G _ { \theta }$ and target latent distribution $P = p _ { \mathrm { d a t a } }$ as
+
+$$
+M _ { \phi } \simeq \frac { 1 } { 2 } ( P + G _ { \theta } ) .
+$$
+
+Since the mediator is only used as a density prediction module during training, the directed KL divergence is now free from so-called exposure bias for optimization of $M _ { \phi }$ . Denote ${ \scriptstyle { \frac { 1 } { 2 } } } ( P + G _ { \theta } )$ as $M ^ { * }$ , we have:
+
+# Lemma 1 (Mixture Density Decomposition)
+
+$$
+\begin{array} { r l } & { \nabla _ { \phi } J _ { m } ( \phi ) = \nabla _ { \phi } K L ( M ^ { * } \| M _ { \phi } ) } \\ & { \quad \quad = \nabla _ { \phi } \underset { s \sim M ^ { * } } { \mathbb { E } } \left[ \log \frac { M ^ { * } ( s ) } { M _ { \phi } ( s ) } \right] } \\ & { \quad \quad \quad = \nabla _ { \phi } \Big ( \ - \underset { s \sim M ^ { * } } { \mathbb { E } } [ \log M _ { \phi } ( s ) ] \Big ) } \\ & { \quad \quad \quad = \nabla _ { \phi } \frac { 1 } { 2 } \Big ( \underset { s \sim G _ { \theta } } { \mathbb { E } } [ - \log ( M _ { \phi } ( s ) ) ] + \underset { s \sim P } { \mathbb { E } } [ - \log ( M _ { \phi } ( s ) ) ] \Big ) } \end{array}
+$$
+
+By Lemma 1, for each step, we can simply mix balanced samples from training data and the generator, then train the mediator via Maximum Likelihood Estimation with the mixed samples. The objective $J _ { m } ( \phi )$ for the mediator $M$ parametrized by $\phi$ therefore becomes
+
+$$
+J _ { m } ( \phi ) = \frac { 1 } { 2 } { \Big ( } \underset { s \sim G _ { \theta } } { \mathbb { E } } [ - \log ( M _ { \phi } ( s ) ) ] + \underset { s \sim P } { \mathbb { E } } [ - \log ( M _ { \phi } ( s ) ) ] { \Big ) } .
+$$
+
+Since the objective of MLE is bias-free for predictive purposes, the estimated $M _ { \phi }$ is also bias-free when adopted for estimating JSD. The training techniques and details will be discussed in Section 4.
+
+After each iteration, the mediator is exploited to optimize an estimated Jensen-Shannon divergence for $G _ { \theta }$ :
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta } J _ { g } ( \theta ) = \nabla _ { \theta } \Big ( - J \hat { S } D ( G _ { \theta } \| P ) \Big ) = \nabla _ { \theta } \Big ( - \frac { 1 } { 2 } \big [ K L ( G _ { \theta } \| M _ { \phi } ) + K L ( P \| M _ { \phi } ) \big ] \Big ) } \\ & { \qquad = \nabla _ { \theta } \left( - \frac { 1 } { 2 } \underbrace { \mathbb { E } } _ { s \sim G _ { \theta } } \left[ \log \frac { G _ { \theta } ( s ) } { M _ { \phi } ( s ) } \right] - \frac { 1 } { 2 } \underbrace { \mathbb { E } } _ { s \sim P } \left[ \log \frac { P ( s ) } { M _ { \phi } ( s ) } \right] \right) = \nabla _ { \theta } \left( - \frac { 1 } { 2 } \underbrace { \mathbb { E } } _ { s \sim G _ { \theta } } \left[ \log \frac { G _ { \theta } ( s ) } { M _ { \phi } ( s ) } \right] \right) . } \end{array}
+$$
+
+Note that the gradient Eq. (10) should be performed for only one step because once $G _ { \theta }$ is updated the current mediator’s estimation $M _ { \phi }$ becomes inaccurate.
+
+For any sequence or prefix of length $t$ , we have:
+
+# Lemma 2 (Markov Backward Reduction)
+
+$$
+\begin{array} { r l } & { \quad \nabla _ { \theta } \Big ( - \frac { 1 } { 2 } \underset { s _ { t } \sim G _ { \theta } } { \mathbb { E } } \left[ \log \frac { G _ { \theta } \left( s _ { t } \right) } { M _ { \phi } \left( s _ { t } \right) } \right] \Big ) } \\ & { = \nabla _ { \theta } \left( - \frac { 1 } { 2 } \underset { s _ { t - 1 } \sim G _ { \theta } } { \mathbb { E } } \left[ \sum _ { s _ { t } } G _ { \theta } ( s _ { t } | s _ { t - 1 } ) \log \frac { G _ { \theta } \left( s _ { t } | s _ { t - 1 } \right) } { M _ { \phi } \left( s _ { t } | s _ { t - 1 } \right) } \right] - \frac { 1 } { 2 } \underset { s _ { t - 1 } \sim G _ { \theta } } { \mathbb { E } } \left[ \log \frac { G _ { \theta } \left( s _ { t - 1 } \right) } { M _ { \phi } \left( s _ { t - 1 } \right) } \right] \right) . } \end{array}
+$$
+
+The detailed derivations can be found in the supplementary material. Note that Lemma 2 can be applied recursively. That is to say, given any sequence $s _ { t }$ of arbitrary length $t$ , optimizing $s _ { t }$ ’s contribution to the expected JSD can be decomposed into optimizing the first term of Eq. (12) and solving an isomorphic problem for $s _ { t - 1 }$ , which is the longest proper prefix of $s _ { t }$ . When $t = 1$ , since in Markov decision process the probability for initial state $s _ { 0 }$ is always 1.0, it is trivial to prove that the final second term becomes 0.
+
+Therefore, Eq. (10) can be reduced through recursively applying Lemma 2. After removing the constant multipliers and denoting the predicted probability distribution over the action space, i.e. $G _ { \theta } ( \cdot | s _ { t } )$ and $\bar { M } _ { \phi } ( \cdot | s _ { t } )$ , as $\pi _ { g } ( s _ { t } )$ and $\pi _ { m } ( s _ { t } )$ respectively, the gradient $\nabla _ { \theta } J _ { g } ( \theta )$ for training generator via Cooperative Training can be formulated as
+
+$$
+\nabla _ { \boldsymbol { \theta } } J _ { g } ( \boldsymbol { \theta } ) = \nabla _ { \boldsymbol { \theta } } \underset { s \sim G _ { \boldsymbol { \theta } } } { \mathbb { E } } \Big [ \sum _ { t = 0 } ^ { n - 1 } \pi _ { g } ( s _ { t } ) ^ { \top } ( \log \pi _ { m } ( s _ { t } ) - \log \pi _ { g } ( s _ { t } ) ) \Big ] .
+$$
+
+For tractable density models with finite discrete action space in each step, the practical effectiveness of this gradient is well guaranteed for the following reasons. First, with a random initialization of the model, the supports of distributions $G _ { \theta }$ and $P$ are hardly disjoint. Second, the first term of Eq. (13) is to minimize the cross entropy between $G$ and $M ^ { * }$ , which tries to enlarge the overlap of two distributions. Third, since the second term of Eq. (13) is equivalent to maximizing the entropy of $G$ , it encourages the support of $G$ to cover the whole action space, which avoids the case of disjoint supports between $G$ and $P$ .
+
+The overall objective of CoT can be formulated as finding the maximal entropy solution of
+
+$$
+\operatorname* { m a x } _ { \theta } \operatorname* { m a x } _ { \phi } \ \operatorname* { \mathbb { E } } _ { s \sim p _ { \mathrm { d a t a } } } \left[ \log ( M _ { \phi } ( s ) ) \right] + \operatorname* { \mathbb { E } } _ { s \sim G _ { \theta } } \left[ \log ( M _ { \phi } ( s ) ) \right] .
+$$
+
+Note the strong connections and differences between the optimization objective of CoT (14) and that of GAN (4). Figure 1 illustrates the whole Cooperative Training process.
+
+![](images/fa8fcb548231cff17e7f3193fe3ca11adc6e75f56be54c802292cf0e7d1e5fb8.jpg)  
+Figure 1: Process of Cooperative Training.
+
+# 3.3 CONVERGENCE ANALYSIS
+
+CoT has theoretical guarantee on its convergence.
+
+Theorem 3 (Jensen-Shannon Consistency) If in each step, the mediator $M _ { \phi }$ of CoT is trained to be optimal, i.e. $\begin{array} { r } { M _ { \phi } = M ^ { * } = \frac { 1 } { 2 } ( G _ { \theta } + P ) } \end{array}$ , then optimization via Eq. (14) leads to minimization of $J S D ( G \| P )$ .
+
+Proof. Let $p$ denote the intermediate states. It would be used in the detailed proof. All we need to show is
+
+$$
+\nabla _ { \boldsymbol { \theta } } \underset { s \sim G _ { \boldsymbol { \theta } } } { \mathbb { E } } \left[ \sum _ { t = 1 } ^ { n } \pi _ { \boldsymbol { g } } ( s _ { t } ) ^ { \top } ( \log \pi _ { m } ( s _ { t } ) - \log \pi _ { \boldsymbol { g } } ( s _ { t } ) ) \right] \propto \nabla _ { \boldsymbol { \theta } } J S D ( P \| G _ { \boldsymbol { \theta } } ) .
+$$
+
+By inversely applying Lemma 2, the left part in Eq. (15) can be recovered as
+
+$$
+\nabla _ { \theta } \Big ( \frac { 1 } { 2 } \mathop { \mathbb { E } } _ { s \sim G _ { \theta } } \Big [ \log \frac { G _ { \theta } ( s ) } { M _ { \phi } ( s ) } \Big ] \Big ) ,
+$$
+
+which is equivalent to
+
+$$
+\nabla _ { \theta } \left( \underset { s \sim G _ { \theta } } { \mathbb { E } } \left[ \log \frac { G _ { \theta } ( s ) } { M _ { \phi } ( s ) } \right] + \underset { s \sim P } { \mathbb { E } } \left[ \log \frac { P ( s ) } { M _ { \phi } ( s ) } \right] \right) .
+$$
+
+Since now mediator is trained to be optimal, i.e. $M _ { \phi } = M ^ { * }$ , we have
+
+$$
+\begin{array} { r l } & { ( 1 7 ) = \nabla _ { \theta } \left( \underset { s \sim G _ { \theta } } { \mathbb { E } } \left[ \log \frac { G _ { \theta } ( s ) } { M ^ { * } ( s ) } \right] + \underset { s \sim P } { \mathbb { E } } \left[ \log \frac { P ( s ) } { M ^ { * } ( s ) } \right] \right) } \\ & { \quad \quad = 2 \nabla _ { \theta } J \hat { S } D ( P \| G _ { \theta } ) \propto \nabla _ { \theta } J \hat { S } D ( P \| G _ { \theta } ) . } \end{array}
+$$
+
+This means training through CoT leads to minimization of $J \hat { S } D ( P \| G _ { \theta } )$ . When the mediator is trained to be optimal, $J \hat { S } D ( P \| G _ { \theta } ) = J S D ( P \| G _ { \theta } )$ . This verifies the theorem.
+
+# 3.4 DISCUSSION
+
+# 3.4.1 ADVANTAGES OVER PREVIOUS METHODS
+
+CoT has several practical advantages over previous methods, including MLE, Scheduled Sampling (SS) (Bengio et al., 2015) and adversarial methods like SeqGAN (Yu et al., 2017).
+
+First, although CoT and GAN both aim to optimize an estimated JSD, CoT is exceedingly more stable than GAN. This is because the two modules, namely generator and mediator, have similar tasks, i.e. to approach the same data distribution generatively and predictively. The superiority of CoT over inconsistent methods like Scheduled Sampling is obvious, since CoT theoretically guarantees the training effectiveness. Compared with methods that require pre-training in order to reduce variance like SeqGAN (Yu et al., 2017), CoT is computationally cheaper. More specifically, under recommended settings, CoT has the same order of computational complexity as MLE.
+
+Besides, CoT works independently. In practice, it does not require model pre-training via conventional methods like MLE. This is the first time that unbiased unsupervised learning is achieved on sequential discrete data without using supervised approximation for variance reduction or sophisticated smoothing as in Wasserstein GAN with gradient penalty (WGAN-GP) (Gulrajani et al., 2017).
+
+# 3.4.2 THE NECESSITY OF THE MEDIATOR
+
+An interesting problem is to ask why we need to train a mediator by mixing the samples from both sources $G$ and $P$ , instead of directly training a predictive model $\hat { P }$ on the training set via MLE. There are basically two points to interpret this.
+
+To apply the efficient training objective 13, one needs to obtain not only the mixture density model $M = { \frac { 1 } { 2 } } { \bar { ( P + G ) } }$ but also its decomposed form in each timestep i.e. $\begin{array} { r } { \dot { M } _ { \phi } ( s ) = \prod _ { t = 1 } ^ { n } M _ { \phi } ( \dot { s } _ { t } | s _ { t - 1 } ) } \end{array}$ , without which the term $\pi _ { m } ( s _ { t } )$ in Eq 13 cannot be computed efficiently. This indicates that if we directly estimate $P$ and compute $M { \overset { \cdot } { = } } { \frac { 1 } { 2 } } ( G + P )$ , the obtained $M$ will be actually useless since its decomposed form is not available.
+
+Besides, as a derivative problem of “exposure bias”, there is no guarantee for the model $\hat { P }$ to work well on the generated samples i.e. $s \sim G _ { \theta }$ to guide the generator towards the target distribution. Given finite observations, the learned distribution $\hat { P }$ is trained to provide correct predictions for samples from the target distribution $P$ . There is no guarantee that $\hat { P }$ can stably provide correct predictions for guiding the generator. Ablation study is provided in the appendix.
+
+# 4 EXPERIMENTS
+
+# 4.1 UNIVERSAL SEQUENCE MODELING IN SYNTHETIC TURING TEST
+
+Following the synthetic data experiment setting in (Yu et al., 2017; Zhu et al., 2018), we design a synthetic Turing test, in which the negative log-likelihood $\mathrm { N L L } _ { o r a c l e }$ from an oracle LSTM is calculated for evaluating the quality of samples from the generator. Particularly, to support our claim that our method causes little mode collapse, we calculated $\mathrm { N L L } _ { t e s t }$ , which is to sample an extra batch of samples from the oracle, and to calculate the negative log-likelihood measured by the generator. We show that under this more reasonable setting, our proposed algorithm reaches the state-of-the-art performance with exactly the same network architecture. Note that models like LeakGAN (Guo et al., 2017) contain architecture-level modification, which is orthogonal to our approach, thus will not be included in this part. The results are shown in Table 1.
+
+# 4.1.1 DISCUSSION
+
+Computational Efficiency Although in terms of time cost per epoch, CoT does not achieve the state-of-the-art, we do observe that CoT is remarkably faster than previous RL-GAN approaches. Besides, consider the fact that CoT is a sample-based optimization algorithm, which involves time cost in sampling from the generator, this result is acceptable. The result also verifies our claim that CoT has the same order (i.e. the time cost only differs in a constant multiplier or extra lower order term) of computational complexity as MLE.
+
+Table 1: Likelihood-based benchmark and time statistics for synthetic Turing test. ‘-(MLE)’ means the best performance is acquired during MLE pre-training.   
+
+<table><tr><td>Model/Algorithm</td><td>NLLoracle</td><td>NLLtest (final/best)</td><td>best NLLoracle+test</td><td>time/epoch</td></tr><tr><td>MLE</td><td>9.08</td><td>8.97/7.60</td><td>9.43 + 7.67</td><td>16.14 ± 0.97s</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>8.68</td><td>10.10/-(MLE)</td><td>(The same as MLE)</td><td>817.64 ± 5.41s</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>8.37</td><td>11.19/-(MLE)</td><td>(The same as MLE)</td><td>1270 ±13.01s</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>8.73</td><td>10.07/-(MLE)</td><td>(The same as MLE)</td><td>741.31 ± 1.45s</td></tr><tr><td>Scheduled Sampling (Bengio et al., 2015)</td><td>8.89</td><td>8.71/-(MLE)</td><td>(The same as MLE)</td><td>32.54 ± 1.14s</td></tr><tr><td>Professor Forcing (Lamb et al.,2016)</td><td>9.43</td><td>8.31/-(MLE)</td><td>(The same as MLE)</td><td>487.13 ± 0.95s</td></tr><tr><td>CoT (ours)</td><td>8.19</td><td>8.03/7.54</td><td>8.19 + 8.03</td><td>53.94 ± 1.01s</td></tr></table>
+
+![](images/0bb75bc9c49f9bc1d43ad68ca62b56d567fa7f08b651591185f7478be49faebe.jpg)  
+Figure 2: Curves of evaluation on JSD, ${ \mathrm { N L L } } _ { o r a c l e }$ during iterations of CoT under different training settings. To show the hyperparameter robustness of CoT, we compared it with the similar results as were evaluated in SeqGAN (Yu et al., 2017).
+
+Hyper-parameter Robustness. We perform a hyper-parameter robustness experiment on synthetic data experiment. When compared with the results of similar experiments as in SeqGAN (Yu et al., 2017), our approach shows less sensitivity to hyper-parameter choices, as shown in Figure 2. Note that since in all our attempts, the evaluated JSD of SeqGAN fails to converge, we evaluated NLLoracle for it as a replacement.
+
+Self-estimated Training Progress Indicator. Like the critic loss, i.e. estimated Earth Mover Distance, in WGANs, we find that the training loss of the mediator (9), namely balanced NLL, can be a real-time training progress indicator as shown in Figure 3. Specifically, in a wide range, balanced NLL is a good estimation of real $J S D ( G \| P )$ with a steady translation, namely, balanced $N L L =$ $J S D ( G \| P ) + H ( G ) + H ( P )$ .
+
+![](images/697f36a7c0a51aa15b14bd0d9a893b0db5dfe997b27792f1c6eb6462966c1892.jpg)  
+Figure 3: (a) Curves of training time $J S D ( G \| P )$ for MLE, SeqGAN and CoT. (b) Curves of balanced NLL and real JSD. Both results are from synthetic data experiments. Note that balanced NLL is considered to have only a constant translation of the estimated JSD by the mediator.
+
+Table 2: N-gram-level quality benchmark: BLEU on test data of EMNLP2017 WMT News   
+
+<table><tr><td>Model/Algorithm</td><td>BLEU-2</td><td>BLEU-3</td><td>BLEU-4</td><td>BLEU-5</td></tr><tr><td>MLE</td><td>0.781</td><td>0.482</td><td>0.225</td><td>0.105</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>0.731</td><td>0.426</td><td>0.181</td><td>0.096</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>0.691</td><td>0.387</td><td>0.178</td><td>0.095</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>0.755</td><td>0.456</td><td>0.179</td><td>0.088</td></tr><tr><td>LeakGAN (Guo et al., 2017)</td><td>0.835</td><td>0.648</td><td>0.437</td><td>0.271</td></tr><tr><td>TextCoT-basic (ours)</td><td>0.785</td><td>0.489</td><td>0.261</td><td>0.152</td></tr><tr><td>TextCoT-strong (ours)</td><td>0.800</td><td>0.501</td><td>0.273</td><td>0.200</td></tr><tr><td>TextCoT-strong (α = 1.5) (ours)</td><td>0.856</td><td>0.701</td><td>0.510</td><td>0.310</td></tr></table>
+
+Table 3: Diversity benchmark: estimated Word Mover Distance (eWMD) and $\mathrm { N L L } _ { t e s t }$   
+
+<table><tr><td>Model/Algorithm</td><td>eWMDtest</td><td>eWMDtrain</td><td>NLLtest</td></tr><tr><td>MLE</td><td>1.015 (σ = 0.023)</td><td>0.947 (σ = 0.019)</td><td>2.365</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>2.900 (σ = 0.025)</td><td>3.118 (σ = 0.018)</td><td>3.122</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>4.451 (σ = 0.083)</td><td>4.829 (σ = 0.021)</td><td>3.083</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>4.891 (σ = :0.061)</td><td>4.962 (σ: 二 0.020)</td><td>3.240</td></tr><tr><td>LeakGAN (Guo et al., 2017)</td><td>1.803 (σ = 0.027)</td><td>1.767 (σ = ：0.023)</td><td>2.327</td></tr><tr><td>TextCoT-basic (ours)</td><td>0.766 (σ = 0.031)</td><td>0.886(σ = 0.019)</td><td>2.247</td></tr><tr><td>TextCoT-strong (ours)</td><td>0.923 (σ = 0.018)</td><td>0.941 (σ = 0.016)</td><td>2.144</td></tr></table>
+
+# 4.2 TEXTCOT: ZERO-PRIOR LONG & DIVERSE TEXT GENERATION
+
+As an important sequential data modeling task, zero-prior text generation, especially long and diversified text generation, is a good testbed for evaluating the performance of a generative model.
+
+Following the experiment proposed in LeakGAN (Guo et al., 2017), we choose EMNLP 2017 WMT News Section as our dataset, with maximal sentence length limited to 51. We pay major attention to both quality and diversity. To keep the comparison fair, we present two implementations of CoT, namely CoT-basic and CoT-strong. As for CoT-basic, the generator follows the settings of that in MLE, SeqGAN, RankGAN and MaliGAN. As for CoT-strong, the generator is implemented with the similar architecture in LeakGAN.
+
+For quality evaluation, we evaluated BLEU on a small batch of test data separated from the original dataset. For diversity evaluation, we evaluated the estimated Word Mover Distance (Kusner et al., 2015), which is calculated through training a discriminative model between generated samples and real samples with 1-Lipschitz constriant via gradient penalty as in WGAN-GP (Gulrajani et al., 2017). To keep it fair, for all evaluated models, the architecture and other training settings of the discriminative models are kept the same.
+
+The results are shown in Table 2 and Table 3. In terms of generative quality, CoT-basic achieves state-of-the-art performance over all the baselines with the same architecture-level capacity, especially the long-term robustness at n-gram level. CoT-strong using a conservative generation strategy, i.e. setting the inverse temperature parameter $\alpha$ higher than 1, as in (Guo et al., 2017) achieves the best performance over all compared models. In terms of generative diversity, the results show that our model achieves the state-of-the-art performance on all metrics including $\mathrm { N L L } _ { t e s t }$ , which is the optimization target of MLE.
+
+# 5 CONCLUSION
+
+We proposed Cooperative Training, a novel training algorithm for generative modeling of discrete data. CoT optimizes Jensen-Shannon Divergence, which does not have the exposure bias problem as the forward KLD. Models trained via CoT shows promising results in sequential discrete data modeling tasks, including sample quality and the generalization ability in likelihood prediction tasks.
+
+# REFERENCES
+
+Martin Arjovsky and Léon Bottou. Towards principled methods for training generative adversarial networks. arXiv preprint arXiv:1701.04862, 2017.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. arXiv:1701.07875, 2017.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv:1409.0473, 2014.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In NIPS, pp. 1171–1179, 2015.
+
+Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv:1702.07983, 2017.
+
+Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In NIPS, pp. 5769–5779, 2017.
+
+Jiaxian Guo, Sidi Lu, Han Cai, Weinan Zhang, Yong Yu, and Jun Wang. Long text generation via adversarial training with leaked information. arXiv:1709.08624, 2017.
+
+Matt Kusner, Yu Sun, Nicholas Kolkin, and Kilian Weinberger. From word embeddings to document distances. In International Conference on Machine Learning, pp. 957–966, 2015.
+
+Alex M Lamb, Anirudh Goyal ALIAS PARTH GOYAL, Ying Zhang, Saizheng Zhang, Aaron C Courville, and Yoshua Bengio. Professor forcing: A new algorithm for training recurrent networks. In NIPS, pp. 4601–4609, 2016.
+
+Kevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for language generation. In NIPS, pp. 3155–3165, 2017.
+
+Sidi Lu, Yaoming Zhu, Weinan Zhang, Jun Wang, and Yong Yu. Neural text generation: Past, present and beyond. arXiv preprint arXiv:1803.07133, 2018.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.
+
+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.
+
+Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984.
+
+Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets with policy gradient. In AAAI, pp. 2852–2858, 2017.
+
+Yaoming Zhu, Sidi Lu, Lei Zheng, Jiaxian Guo, Weinan Zhang, Jun Wang, and Yong Yu. Texygen: A benchmarking platform for text generation models. arXiv:1802.01886, 2018.
+
+# A DETAILED DERIVATION OF THE ALGORITHM
+
+$$
+\begin{array} { r l } & { \quad = x _ { 1 } \left( - \frac { 1 } { 2 } \sum _ { k _ { 1 } \geq 0 } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } \right) } \\ & { \quad = - \frac { 1 } { 2 } \mathbb { E } \left( \sum _ { k _ { 1 } \geq 0 } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } - 1 \right) ^ { 2 } } \\ & { \qquad - \frac { 1 } { 2 } \mathbb { E } \left( \sum _ { k _ { 1 } \geq 0 } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } - 1 \right) \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } } \\ & { \qquad - \frac { 1 } { 2 } \mathbb { E } \left( \sum _ { k _ { 1 } \geq 0 } \frac { \partial _ { k } ( k _ { 1 } - 1 ) \partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } - 1 \right) } \\ &  \qquad - \frac { 1 } { 2 } \mathbb { E } \left( \sum _ { k _ { 1 } \geq 0 } \frac { \partial _ { k } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } \frac { \partial _ { k } ( k _ { 1 } - 1 ) } { \partial _ { k } ( k _ { 1 } - 1 ) } - 1 \right) \alpha ^ { 2 } \beta \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \beta \alpha ^ { 2 } \beta \alpha ^ { 2 } \beta \beta \end{array}
+$$
+
+# B SAMPLE COMPARISON AND DISCUSSION
+
+Table 4 shows samples from some of the most powerful baseline models and our model.
+
+Observation of the model samples indicates that:
+
+• CoT produces remarkably more diverse and meaningful samples when compared to LeakGAN. • The consistency of CoT is significantly improved when compared to MLE.
+
+# C FURTHER DISCUSSIONS ABOUT THE EXPERIMENT RESULTS
+
+The Optimal Balance for Cooperative Training We find that the same learning rate and iteration numbers for the generator and mediator seems to be the most competitive choice. As for the architecture choice, we find that the mediator needs to be slightly stronger than the generator. For the best result in the synthetic experiment, we adopt exactly the same generator as other compared models and a mediator whose hidden state size is twice larger (with 64 hidden units) than the generator.
+
+Theoretically speaking, we can and we should sample more batches from $G _ { \theta }$ and $P$ respectively for training the mediator in each iteration. However, if no regularizations are used when training the mediator, it can easily over-fit, leading the generator’s quick convergence in terms of $K L ( G _ { \theta } | | P )$ or ${ \mathrm { N L L } } _ { o r a c l e }$ , but divergence in terms of $J S D ( G _ { \theta } \| P )$ . Empirically, this could be alleviated by applying dropout techniques (Srivastava et al., 2014) with $50 \%$ keeping ratio before the output layer of RNN. After applying dropout, the empirical results show good consistency with our theory that, more training batches for the mediator in each iteration is always helpful.
+
+However, applying regularizations is not an ultimate solution and we look forward to further theoretical investigation on better solutions for this problem in the future.
+
+Table 4: WMT News Samples from Different Models   
+
+<table><tr><td rowspan=1 colspan=1>Sources</td><td rowspan=1 colspan=1>Example</td></tr><tr><td rowspan=1 colspan=1>LeakGAN</td><td rowspan=1 colspan=1>(1) It&#x27;s a big advocate for therapy is a second thing to do, and I&#x27;m creating a relationshipwith a nation.(2) It&#x27;s probably for a fantastic footage of the game,but in the United States is alreadytime to be taken to live.(3) It&#x27;s a sad House we have a way to get the right because we have to go to see that,” shesaid.(4)I&#x27;m not sure if I thank a litle bit easier to get to my future commitment in work,”hesaid.(5)“I think it was alone because Ican do that, when you&#x27;re a lot of reasons,”he said.(6) It&#x27;s the only thing we do,we spent 26 and $35(see how you do is we lose it,” said bothsides in the summer.</td></tr><tr><td rowspan=1 colspan=1>CoT</td><td rowspan=1 colspan=1>(1) We focus the plans to put aside either now,and which doesn&#x27;t mean it is to earn theimpact to the government rejected.(2) The argument would be very doing work on the 2O14 campaign to pursue the firm andimmigration officials,the new review that’s taken up for parking.(3) This method is true to available we make up drink with that all they were willing topay down smoking.(4) The number of people who are on the streaming boat would study if the children had abottle - but meant to be much easier,having serious ties to the outside of the nation.(5)However,they have to wait to get the plant in federal fees and the housing market&#x27;smost valuable in tourism.</td></tr><tr><td rowspan=1 colspan=1>MLE</td><td rowspan=1 colspan=1>(1) after the possible cost of military regulatory scientists,chancellor angela merkel&#x27;sbusiness share together a conflict of major operators and interest as they said it is unknownfor those probably1OO percent as a missile for britain.(2) but which have yet to involve the right climb that took in melbourne somewhere elsewith the rams even a second running mate and kansas.(3)“la la la la 3O who appeared that themselves is in the room when they were shot heruntil the end ”that jose mourinho could risen from the individual .(4) when aaron you has died,it is thought if you took your room at the prison fines ofradical controls by everybody, if it&#x27;s a digital plan at an future of the next time.</td></tr></table>
+
+Possible Derivatives of CoT The form of equation 13 can be modified to optimize other objectives. One example is the backward KLD (a.k.a. Reverse KLD) i.e. $K L ( G \| P )$ . In this case, the objective of the so-called “Mediator” and “Generator” thus becomes:
+
+“Mediator”, now it becomes a direct estimator $\hat { P } _ { \phi }$ of the target distribution $P$ :
+
+$$
+J _ { \hat { p } } ( \phi ) = \underset { s \sim P } { \mathbb { E } } [ - \log ( \hat { P } _ { \phi } ( s ) ) ] .
+$$
+
+Generator:
+
+$$
+\nabla _ { \boldsymbol { \theta } } J _ { g } ( \boldsymbol { \theta } ) = \nabla _ { \boldsymbol { \theta } } \underset { s \sim G _ { \boldsymbol { \theta } } } { \mathbb { E } } \Big [ \sum _ { t = 0 } ^ { n - 1 } \pi _ { g } ( s _ { t } ) ^ { \top } ( \log \pi _ { \hat { p } } ( s _ { t } ) - \log \pi _ { g } ( s _ { t } ) ) \Big ] .
+$$
+
+Such a model suffers from so-called mode-collapse problem, as is analyzed in Ian’s GAN Tutorial (Goodfellow, 2016). Besides, as the distribution estimator $\hat { P } \phi$ inevitably introduces unpredictable behaviors when given unseen samples i.e. samples from the generator, the algorithm sometimes fails (numerical error) or diverges.
+
+In our successful attempts, the algorithm produces similar (not significantly better than) results as CoT. The quantitive results are shown as follows:
+
+Table 5: N-gram-level quality benchmark: BLEU on test data of EMNLP2017 WMT News (New Split)   
+
+<table><tr><td>Model/Algorithm</td><td>BLEU-2</td><td>BLEU-3</td><td>BLEU-4</td><td>BLEU-5</td><td>eWMD</td></tr><tr><td>CoT-basic (ours)</td><td>0.850</td><td>0.571</td><td>0.316</td><td>0.169</td><td>1.001 (σ = 0.020)</td></tr><tr><td>Reverse KL (ours)</td><td>0.860</td><td>0.590</td><td>0.335</td><td>0.181</td><td>1.086 (σ = 0.014)</td></tr></table>
+
+Although under evaluation of weak metrics like BLEU, if successfully trained, the model trained via Reverse KL seems to be better than that trained via CoT, the disadvantage of Reverse KL under evaluation of more strict metric like eWMD indicates that Reverse KL does fail in learning some aspects of the data patterns e.g. completely covering the data mode.

parse/train/SkxxIs0qY7/SkxxIs0qY7_content_list.json

@@ -0,0 +1,1677 @@
+[
+    {
+        "type": "text",
+        "text": "COT: COOPERATIVE TRAINING FOR GENERATIVEMODELING OF DISCRETE DATA",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose Cooperative Training (CoT) for training generative models that measure a tractable density for discrete data. CoT coordinately trains a generator $G$ and an auxiliary predictive mediator $M$ . The training target of $M$ is to estimate a mixture density of the learned distribution $G$ and the target distribution $P$ , and that of $G$ is to minimize the Jensen-Shannon divergence estimated through $M$ . CoT achieves independent success without the necessity of pre-training via Maximum Likelihood Estimation or involving high-variance algorithms like REINFORCE. This low-variance algorithm is theoretically proved to be superior for both sample generation and likelihood prediction. We also theoretically and empirically show the superiority of CoT over most previous algorithms in terms of generative quality and diversity, predictive generalization ability and computational cost. ",
+        "bbox": [
+            233,
+            267,
+            766,
+            421
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            336,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative modeling is essential in many scenarios, including continuous data modeling (e.g. image generation (Goodfellow et al., 2014; Arjovsky et al., 2017), stylization (Ulyanov et al., 2016), semisupervised classification (Radford et al., 2015)) and sequential discrete data modeling (e.g. neural text generation (Bahdanau et al., 2014; Yu et al., 2017; Lu et al., 2018)). ",
+        "bbox": [
+            176,
+            484,
+            825,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For discrete data with tractable density like natural language, generative models are predominantly optimized through Maximum Likelihood Estimation (MLE), inevitably introducing exposure bias (Ranzato et al., 2015), which results in that given a finite set of observations, the optimal parameters of the model trained via MLE do not correspond to the ones maximizing the generative quality. Specifically, the model is trained on the data distribution of inputs and tested on a different distribution of inputs, namely, the learned distribution. This discrepancy implies that in the training stage, the model is never exposed to its own errors and thus in the test stage, the errors made along the way will quickly accumulate. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, for general generative modeling tasks, an effective framework, named Generative Adversarial Network (GAN) (Goodfellow et al., 2014), was proposed to train an implicit density model for continuous data. GAN introduces a discriminator $D _ { \\phi }$ parametrized by $\\phi$ to distinguish the generated samples from the real ones. As is proved in (Goodfellow et al., 2014), GAN essentially optimizes an approximately estimated Jensen-Shannon divergence (JSD) between the currently learned distribution and the target distribution. GAN shows promising results in many unsupervised and semi-supervised learning tasks. The success of GAN results in the naissance of a new paradigm of deep generative models, i.e. adversarial networks. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, since the gradient computation requires backpropagation through the generator’s output, GAN can only model the distribution of continuous variables, making it non-applicable for generating discrete sequences like natural language. Researchers then proposed Sequence Generative Adversarial Network (SeqGAN) (Yu et al., 2017), which uses model-free policy gradient algorithm to optimize the original GAN objective. With SeqGAN, the expected JSD between current and target discrete data distribution is minimized if the training is perfect. SeqGAN shows observable improvements in many tasks. Since then, many variants of SeqGAN have been proposed to improve its performance. Nonetheless, SeqGAN is not an ideal algorithm for this problem, and current algorithms based on it cannot show stable, reliable and observable improvements that covers all scenarios, according to a previous survey (Lu et al., 2018). The detailed reason will be discussed in detail in Section 2. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose Cooperative Training (CoT), a novel, low-variance, bias-free algorithm for training likelihood-based generative models on discrete data by directly optimizing a wellestimated Jensen-Shannon divergence. CoT coordinately trains a generative module $G$ , and an auxiliary predictive module $M$ , called mediator, for guiding $G$ in a cooperative fashion. For theoretical soundness, we derive the proposed algorithm directly from the definition of JSD. We further empirically and theoretically demonstrate the superiority of our algorithm over many strong baselines in terms of generative performance, generalization ability and computational performance in both synthetic and real-world scenarios. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            326,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notations. $P$ denotes the target data distribution. $\\theta$ denotes the parameters of the generative module $G$ . $\\phi$ denotes the parameters of the auxiliary predictive mediator module $M$ . Any symbol with subscript $g$ and $m$ stands for that of the generator and mediator, respectively. $s$ stands for a complete sample from the training dataset or a generated complete sequence, depending on the specific context. $s _ { t }$ means the $t$ -length prefix of the original sequence, i.e. an incomplete sequence of length $t$ . $x$ denotes a token, and $x _ { t }$ stands for a token that appears in the $t { \\cdot }$ -th place of a sequence. Thus $s _ { t } = [ x _ { 0 } , x _ { 1 } , x _ { 2 } , \\ldots , x _ { t - 1 } ]$ while the initial case $s _ { 0 }$ is $\\varnothing$ . ",
+        "bbox": [
+            173,
+            265,
+            826,
+            364
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MAXIMUM LIKELIHOOD ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            477,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Maximum likelihood estimation is equivalent to minimizing the KL divergence using the samples from the real distribution: ",
+        "bbox": [
+            173,
+            405,
+            823,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17530445f95f5c36b75764d5bbaeec9bcd85e2619725e503ca3cbf9050e68e58.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { s \\sim p _ { \\mathrm { d a t a } } } \\left[ - \\log G _ { \\theta } ( s ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            431,
+            589,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $G _ { \\theta } ( s )$ is the estimated probability of $s$ by $G _ { \\theta }$ and $p _ { \\mathrm { d a t a } }$ is the underlying real distribution. ",
+        "bbox": [
+            171,
+            455,
+            800,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Limitations of MLE. MLE is essentially equivalent to optimizing a directed Kullback–Leibler (KL) divergence between the target distribution $P$ and the currently learned distribution $G$ , denoted as $K L ( P \\| G )$ . However, since KL divergence is asymmetric, given finite observations this target is actually not ideal. As stated in (Arjovsky & Bottou, 2017), MLE tries to minimize ",
+        "bbox": [
+            173,
+            477,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efc1196d77b3f0ed198ad8454c02c19b7e5b9656b78cb220f1fdd22b03465e8d.jpg",
+        "text": "$$\nK L ( P \\| G ) = \\sum _ { s } P ( s ) \\log { \\frac { P ( s ) } { G ( s ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            535,
+            612,
+            574
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• When $P ( s ) > 0$ and $G ( s ) \\to 0$ , the KL divergence grows to infinity, which means MLE assigns an extremely high cost to the “mode dropping” scenarios, where the generator fails to cover some parts of the data. When $G ( s ) > 0$ and $P ( s ) \\to 0$ , the KL divergence shrinks to 0, which means MLE assigns an extremely low cost to the scenarios, where the model generates some samples that do not locate on the data distribution. ",
+        "bbox": [
+            215,
+            582,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Likewise, optimizing $K L ( G \\| P )$ will lead to exactly the reversed problems of the two situations. An ideal solution is to optimize a symmetrized and smoothed version of KL divergence, i.e. the Jensen-Shannon divergence (JSD), which is defined as ",
+        "bbox": [
+            174,
+            681,
+            825,
+            723
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93862c4fe15c4121fb5b5c0da3a6cd80a8b9f8ccd052a6ec2b748b68e6fe295c.jpg",
+        "text": "$$\nJ S D ( P \\| G ) = \\frac { 1 } { 2 } \\big ( K L ( P \\| M ) + K L ( G \\| M ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            726,
+            655,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $M = { \\textstyle \\frac { 1 } { 2 } } ( P + G )$ . However, directly optimizing JSD is conventionally considered as an intractable problem. JSD cannot be directly evaluated and optimized since the equally interpolated distribution $M$ is usually considered to be unconstructable, as we only have access to the learned model $G$ instead of $P$ . ",
+        "bbox": [
+            174,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 SEQUENCE GENERATIVE ADVERSARIAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            832,
+            571,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SeqGAN incorporates two modules, i.e. the generator and discriminator, parametrized by $\\theta$ and $\\phi$ respectively, as in the settings of GAN. By alternatively training these two modules, SeqGAN optimizes such an adversarial target: ",
+        "bbox": [
+            174,
+            858,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07275fc2cbf76512047bd901a5ebbb507ded8f41f9576b5007c0e791f22abcd6.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\operatorname* { m a x } _ { \\phi } \\mathbb { E } _ { s \\sim p _ { \\mathrm { d a t a } } } \\left[ \\log ( D _ { \\phi } ( s ) ) \\right] + \\mathbb { E } _ { s \\sim G _ { \\theta } } \\left[ \\log ( 1 - D _ { \\phi } ( s ) ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            904,
+            696,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Cooperative Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            403,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Require: Generator $G _ { \\theta }$ ; mediator $M _ { \\phi }$ ; samples from real data distribution $P$ ; hyper-parameter $N _ { m }$ .   \n1: Initialize $G _ { \\theta }$ , $M _ { \\phi }$ with random weights $\\theta , \\phi$ .   \n2: repeat   \n3: for $N _ { m }$ steps do   \n4: Collect two equal-sized mini-batch of samples $\\{ s _ { g } \\}$ and $\\{ s _ { p } \\}$ from $G _ { \\theta }$ and $P$ , respectively   \n5: Mix $\\{ s _ { g } \\}$ and $\\{ s _ { p } \\}$ as $\\{ s \\}$   \n6: Update mediator $M _ { \\phi }$ with $\\{ s \\}$ via Eq. (9)   \n7: end for   \n8: Generate a mini-batch of sequences $\\{ s \\} \\sim G _ { \\theta }$   \n9: Update generator $G _ { \\theta }$ with $\\{ s \\}$ via Eq. (13)   \n10: until CoT converges ",
+        "bbox": [
+            176,
+            121,
+            772,
+            262
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The objectives of generator $G _ { \\theta }$ and discriminator $D _ { \\phi }$ in SeqGAN can be formulated as ",
+        "bbox": [
+            174,
+            295,
+            741,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4989cf33c580f9edaeb583107f6f1c2bf91a8dcebd0dd98b7100fed20a044210.jpg",
+        "text": "$$\n\\mathrm { G e n e r a t o r : \\quad } \\operatorname* { m i n } _ { \\theta } - \\mathbb { E } _ { s \\sim G _ { \\theta } } \\Big [ \\sum _ { t = 1 } ^ { n } Q _ { t } ( s _ { t } , x _ { t } ) \\cdot \\log G _ { \\theta } ( x _ { t } | s _ { t } ) \\Big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            324,
+            694,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afaec01d657c829e9842353488a142c75fc0079b99be7399d10ef9b414a85193.jpg",
+        "text": "$$\n\\mathrm { i n a t o r : } \\quad \\operatorname* { m a x } _ { \\phi } \\mathbb { E } _ { s \\sim p _ { \\mathrm { d a t a } } } \\left[ \\log ( D _ { \\phi } ( s ) ) \\right] + \\mathbb { E } _ { s \\sim G _ { \\theta } } \\left[ \\log ( 1 - D _ { \\phi } ( s ) ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            383,
+            735,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s \\sim G _ { \\boldsymbol \\theta } = [ x _ { 1 } , . . . , x _ { n } ]$ denotes a complete sequence sampled from the generator and the action value $Q _ { t } ( s _ { t } , x _ { t } ) \\stackrel { - } { = } \\mathbb { E } _ { s \\sim G _ { \\theta } ( \\cdot | s _ { t + 1 } ) } \\left[ D _ { \\phi } ( s ) \\right]$ is the expectation of the discriminator’s evaluation on the completed sequences sampled from the prefix $\\boldsymbol { s } _ { t + 1 } = \\left[ \\boldsymbol { s } _ { t } , \\boldsymbol { x } _ { t } \\right]$ , which can be approximated via Monte Carlo search. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Limitations of SeqGAN & its Variants. First, SeqGAN is an algorithm of high variance, which relies on pre-training via Maximum Likelihood Estimation as a variance reduction procedure. Besides, during the adversarial epochs, even if with variance reduction techniques such as Actor-Critic methods (Sutton, 1984), the fact that SeqGAN is essentially based on model-free reinforcement learning makes it a non-trivial problem for SeqGAN to converge well. As a result, SeqGAN usually gets stuck in some fake local optimals. Specifically, although the discriminator can distinguish the samples from the generator easily, it is not able to effectively guide the generator because of the vanishing gradient, as is discussed in a recent survey (Lu et al., 2018). Although this problem can be alleviated by reshaping the reward signals based on the relative rankings of the outputs in a mini-batch (Lin et al., 2017; Guo et al., 2017), they are more technical workarounds than essential solutions. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Second, SeqGAN trained via REINFORCE (Williams, 1992) suffers from the “mode collapse” problem, which is similar to the original GAN. That is to say, the learned distribution “collapses” to the other side of KL divergence, i.e. $K L ( G \\| P )$ , which leads to the loss of diversity of generated samples. In other words, SeqGAN trains the model for better generative quality at the cost of diversity. ",
+        "bbox": [
+            174,
+            631,
+            826,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 COOPERATIVE TRAINING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            416,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            305,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To be consistent with the goal that the target distribution should be well-estimated in both quality and diversity senses, an ideal algorithm for such models should be able to optimize a symmetric divergence or distance. ",
+        "bbox": [
+            178,
+            776,
+            823,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For sequential discrete data modeling, since the data distribution is decomposed into a sequential product of finite-dimension multinomial distributions (always based on the softmax form), the failures of effectively optimizing JSD when the generated and real data distributions are distant, as discussed in (Arjovsky et al., 2017), will not appear. As such, to optimize JSD is feasible. However, to our knowledge, no previous algorithms provide a direct, low-variance optimization of JSD. In this paper, we propose Cooperative Training (CoT), as shown in Algorithm 1, to directly optimize a well-estimated unbiased JSD for training such models. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 ALGORITHM DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            395,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each iteration of Cooperative Training mainly consists of two parts. The first part is to train a mediator $M _ { \\phi }$ , which is a density function that estimates a mixture distribution of the learned generative distribution $G _ { \\theta }$ and target latent distribution $P = p _ { \\mathrm { d a t a } }$ as ",
+        "bbox": [
+            173,
+            128,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c55d23a3ea527eea0241cca083e8e66f9020eca6d64d874c7709215d441168f8.jpg",
+        "text": "$$\nM _ { \\phi } \\simeq \\frac { 1 } { 2 } ( P + G _ { \\theta } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            178,
+            565,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the mediator is only used as a density prediction module during training, the directed KL divergence is now free from so-called exposure bias for optimization of $M _ { \\phi }$ . Denote ${ \\scriptstyle { \\frac { 1 } { 2 } } } ( P + G _ { \\theta } )$ as $M ^ { * }$ , we have: ",
+        "bbox": [
+            174,
+            213,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 (Mixture Density Decomposition) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            266,
+            478,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a70ecbabd6c9a0af15a3949e6d437d5094dfe2d4f76b3028e224d79a080f8e1a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\phi } J _ { m } ( \\phi ) = \\nabla _ { \\phi } K L ( M ^ { * } \\| M _ { \\phi } ) } \\\\ & { \\quad \\quad = \\nabla _ { \\phi } \\underset { s \\sim M ^ { * } } { \\mathbb { E } } \\left[ \\log \\frac { M ^ { * } ( s ) } { M _ { \\phi } ( s ) } \\right] } \\\\ & { \\quad \\quad \\quad = \\nabla _ { \\phi } \\Big ( \\ - \\underset { s \\sim M ^ { * } } { \\mathbb { E } } [ \\log M _ { \\phi } ( s ) ] \\Big ) } \\\\ & { \\quad \\quad \\quad = \\nabla _ { \\phi } \\frac { 1 } { 2 } \\Big ( \\underset { s \\sim G _ { \\theta } } { \\mathbb { E } } [ - \\log ( M _ { \\phi } ( s ) ) ] + \\underset { s \\sim P } { \\mathbb { E } } [ - \\log ( M _ { \\phi } ( s ) ) ] \\Big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            286,
+            714,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By Lemma 1, for each step, we can simply mix balanced samples from training data and the generator, then train the mediator via Maximum Likelihood Estimation with the mixed samples. The objective $J _ { m } ( \\phi )$ for the mediator $M$ parametrized by $\\phi$ therefore becomes ",
+        "bbox": [
+            176,
+            417,
+            823,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/362f89a9c2701099ece8bb61f49b52c1d45b2354967de0e05ce10ba8510e8e79.jpg",
+        "text": "$$\nJ _ { m } ( \\phi ) = \\frac { 1 } { 2 } { \\Big ( } \\underset { s \\sim G _ { \\theta } } { \\mathbb { E } } [ - \\log ( M _ { \\phi } ( s ) ) ] + \\underset { s \\sim P } { \\mathbb { E } } [ - \\log ( M _ { \\phi } ( s ) ) ] { \\Big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            465,
+            696,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the objective of MLE is bias-free for predictive purposes, the estimated $M _ { \\phi }$ is also bias-free when adopted for estimating JSD. The training techniques and details will be discussed in Section 4. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After each iteration, the mediator is exploited to optimize an estimated Jensen-Shannon divergence for $G _ { \\theta }$ : ",
+        "bbox": [
+            174,
+            547,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2617d3c63e74888b6ad6d56688a8206ae322e67a3dc6de61f17c822eba4d0a2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\theta } J _ { g } ( \\theta ) = \\nabla _ { \\theta } \\Big ( - J \\hat { S } D ( G _ { \\theta } \\| P ) \\Big ) = \\nabla _ { \\theta } \\Big ( - \\frac { 1 } { 2 } \\big [ K L ( G _ { \\theta } \\| M _ { \\phi } ) + K L ( P \\| M _ { \\phi } ) \\big ] \\Big ) } \\\\ & { \\qquad = \\nabla _ { \\theta } \\left( - \\frac { 1 } { 2 } \\underbrace { \\mathbb { E } } _ { s \\sim G _ { \\theta } } \\left[ \\log \\frac { G _ { \\theta } ( s ) } { M _ { \\phi } ( s ) } \\right] - \\frac { 1 } { 2 } \\underbrace { \\mathbb { E } } _ { s \\sim P } \\left[ \\log \\frac { P ( s ) } { M _ { \\phi } ( s ) } \\right] \\right) = \\nabla _ { \\theta } \\left( - \\frac { 1 } { 2 } \\underbrace { \\mathbb { E } } _ { s \\sim G _ { \\theta } } \\left[ \\log \\frac { G _ { \\theta } ( s ) } { M _ { \\phi } ( s ) } \\right] \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            580,
+            838,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the gradient Eq. (10) should be performed for only one step because once $G _ { \\theta }$ is updated the current mediator’s estimation $M _ { \\phi }$ becomes inaccurate. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For any sequence or prefix of length $t$ , we have: ",
+        "bbox": [
+            173,
+            702,
+            488,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2 (Markov Backward Reduction) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            464,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3e67b5f9ed0c7c74fffabd6fb2560e1dea35374c69f0a138ce4a903f4eafb37.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\nabla _ { \\theta } \\Big ( - \\frac { 1 } { 2 } \\underset { s _ { t } \\sim G _ { \\theta } } { \\mathbb { E } } \\left[ \\log \\frac { G _ { \\theta } \\left( s _ { t } \\right) } { M _ { \\phi } \\left( s _ { t } \\right) } \\right] \\Big ) } \\\\ & { = \\nabla _ { \\theta } \\left( - \\frac { 1 } { 2 } \\underset { s _ { t - 1 } \\sim G _ { \\theta } } { \\mathbb { E } } \\left[ \\sum _ { s _ { t } } G _ { \\theta } ( s _ { t } | s _ { t - 1 } ) \\log \\frac { G _ { \\theta } \\left( s _ { t } | s _ { t - 1 } \\right) } { M _ { \\phi } \\left( s _ { t } | s _ { t - 1 } \\right) } \\right] - \\frac { 1 } { 2 } \\underset { s _ { t - 1 } \\sim G _ { \\theta } } { \\mathbb { E } } \\left[ \\log \\frac { G _ { \\theta } \\left( s _ { t - 1 } \\right) } { M _ { \\phi } \\left( s _ { t - 1 } \\right) } \\right] \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            747,
+            787,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The detailed derivations can be found in the supplementary material. Note that Lemma 2 can be applied recursively. That is to say, given any sequence $s _ { t }$ of arbitrary length $t$ , optimizing $s _ { t }$ ’s contribution to the expected JSD can be decomposed into optimizing the first term of Eq. (12) and solving an isomorphic problem for $s _ { t - 1 }$ , which is the longest proper prefix of $s _ { t }$ . When $t = 1$ , since in Markov decision process the probability for initial state $s _ { 0 }$ is always 1.0, it is trivial to prove that the final second term becomes 0. ",
+        "bbox": [
+            173,
+            839,
+            826,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, Eq. (10) can be reduced through recursively applying Lemma 2. After removing the constant multipliers and denoting the predicted probability distribution over the action space, i.e. $G _ { \\theta } ( \\cdot | s _ { t } )$ and $\\bar { M } _ { \\phi } ( \\cdot | s _ { t } )$ , as $\\pi _ { g } ( s _ { t } )$ and $\\pi _ { m } ( s _ { t } )$ respectively, the gradient $\\nabla _ { \\theta } J _ { g } ( \\theta )$ for training generator via Cooperative Training can be formulated as ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ecbd4913b5be01589f3675b928dec40fd713c714f162bef04d3541b627441c45.jpg",
+        "text": "$$\n\\nabla _ { \\boldsymbol { \\theta } } J _ { g } ( \\boldsymbol { \\theta } ) = \\nabla _ { \\boldsymbol { \\theta } } \\underset { s \\sim G _ { \\boldsymbol { \\theta } } } { \\mathbb { E } } \\Big [ \\sum _ { t = 0 } ^ { n - 1 } \\pi _ { g } ( s _ { t } ) ^ { \\top } ( \\log \\pi _ { m } ( s _ { t } ) - \\log \\pi _ { g } ( s _ { t } ) ) \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            162,
+            709,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For tractable density models with finite discrete action space in each step, the practical effectiveness of this gradient is well guaranteed for the following reasons. First, with a random initialization of the model, the supports of distributions $G _ { \\theta }$ and $P$ are hardly disjoint. Second, the first term of Eq. (13) is to minimize the cross entropy between $G$ and $M ^ { * }$ , which tries to enlarge the overlap of two distributions. Third, since the second term of Eq. (13) is equivalent to maximizing the entropy of $G$ , it encourages the support of $G$ to cover the whole action space, which avoids the case of disjoint supports between $G$ and $P$ . ",
+        "bbox": [
+            173,
+            208,
+            826,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The overall objective of CoT can be formulated as finding the maximal entropy solution of ",
+        "bbox": [
+            169,
+            311,
+            767,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95cddfeb2c27caec26fbbb3b1f431eccf799af4907c01173d9a9d94a25ff6cfa.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } \\operatorname* { m a x } _ { \\phi } \\ \\operatorname* { \\mathbb { E } } _ { s \\sim p _ { \\mathrm { d a t a } } } \\left[ \\log ( M _ { \\phi } ( s ) ) \\right] + \\operatorname* { \\mathbb { E } } _ { s \\sim G _ { \\theta } } \\left[ \\log ( M _ { \\phi } ( s ) ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            329,
+            673,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note the strong connections and differences between the optimization objective of CoT (14) and that of GAN (4). Figure 1 illustrates the whole Cooperative Training process. ",
+        "bbox": [
+            171,
+            358,
+            826,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa8fcb548231cff17e7f3193fe3ca11adc6e75f56be54c802292cf0e7d1e5fb8.jpg",
+        "image_caption": [
+            "Figure 1: Process of Cooperative Training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            397,
+            756,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 CONVERGENCE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            398,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CoT has theoretical guarantee on its convergence. ",
+        "bbox": [
+            176,
+            577,
+            500,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Jensen-Shannon Consistency) If in each step, the mediator $M _ { \\phi }$ of CoT is trained to be optimal, i.e. $\\begin{array} { r } { M _ { \\phi } = M ^ { * } = \\frac { 1 } { 2 } ( G _ { \\theta } + P ) } \\end{array}$ , then optimization via Eq. (14) leads to minimization of $J S D ( G \\| P )$ . ",
+        "bbox": [
+            173,
+            603,
+            828,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. Let $p$ denote the intermediate states. It would be used in the detailed proof. All we need to show is ",
+        "bbox": [
+            174,
+            659,
+            825,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/172eeba46db38fdbf47f5808b7f0783f0d3a1330b7e48f55c7b8d5be21f169fb.jpg",
+        "text": "$$\n\\nabla _ { \\boldsymbol { \\theta } } \\underset { s \\sim G _ { \\boldsymbol { \\theta } } } { \\mathbb { E } } \\left[ \\sum _ { t = 1 } ^ { n } \\pi _ { \\boldsymbol { g } } ( s _ { t } ) ^ { \\top } ( \\log \\pi _ { m } ( s _ { t } ) - \\log \\pi _ { \\boldsymbol { g } } ( s _ { t } ) ) \\right] \\propto \\nabla _ { \\boldsymbol { \\theta } } J S D ( P \\| G _ { \\boldsymbol { \\theta } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            681,
+            735,
+            723
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By inversely applying Lemma 2, the left part in Eq. (15) can be recovered as ",
+        "bbox": [
+            173,
+            731,
+            676,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e55c0d0dab123aa315661dfe0721fad1805e2ab8f47d18a6d4a685bd6d921de.jpg",
+        "text": "$$\n\\nabla _ { \\theta } \\Big ( \\frac { 1 } { 2 } \\mathop { \\mathbb { E } } _ { s \\sim G _ { \\theta } } \\Big [ \\log \\frac { G _ { \\theta } ( s ) } { M _ { \\phi } ( s ) } \\Big ] \\Big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            748,
+            593,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which is equivalent to ",
+        "bbox": [
+            173,
+            785,
+            318,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/54d2c2494f9d3f2f5d7379821cee9d5d93135b4d3995e86c1746494812abb622.jpg",
+        "text": "$$\n\\nabla _ { \\theta } \\left( \\underset { s \\sim G _ { \\theta } } { \\mathbb { E } } \\left[ \\log \\frac { G _ { \\theta } ( s ) } { M _ { \\phi } ( s ) } \\right] + \\underset { s \\sim P } { \\mathbb { E } } \\left[ \\log \\frac { P ( s ) } { M _ { \\phi } ( s ) } \\right] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            803,
+            661,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since now mediator is trained to be optimal, i.e. $M _ { \\phi } = M ^ { * }$ , we have ",
+        "bbox": [
+            176,
+            847,
+            627,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f449156a717cc83ecbbc12a38db06503054bfa62331fc021c07beb746fb366a5.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ( 1 7 ) = \\nabla _ { \\theta } \\left( \\underset { s \\sim G _ { \\theta } } { \\mathbb { E } } \\left[ \\log \\frac { G _ { \\theta } ( s ) } { M ^ { * } ( s ) } \\right] + \\underset { s \\sim P } { \\mathbb { E } } \\left[ \\log \\frac { P ( s ) } { M ^ { * } ( s ) } \\right] \\right) } \\\\ & { \\quad \\quad = 2 \\nabla _ { \\theta } J \\hat { S } D ( P \\| G _ { \\theta } ) \\propto \\nabla _ { \\theta } J \\hat { S } D ( P \\| G _ { \\theta } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            866,
+            681,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This means training through CoT leads to minimization of $J \\hat { S } D ( P \\| G _ { \\theta } )$ . When the mediator is trained to be optimal, $J \\hat { S } D ( P \\| G _ { \\theta } ) = J S D ( P \\| G _ { \\theta } )$ . This verifies the theorem. ",
+        "bbox": [
+            173,
+            102,
+            823,
+            135
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            302,
+            165
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4.1 ADVANTAGES OVER PREVIOUS METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            176,
+            517,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CoT has several practical advantages over previous methods, including MLE, Scheduled Sampling (SS) (Bengio et al., 2015) and adversarial methods like SeqGAN (Yu et al., 2017). ",
+        "bbox": [
+            174,
+            202,
+            823,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, although CoT and GAN both aim to optimize an estimated JSD, CoT is exceedingly more stable than GAN. This is because the two modules, namely generator and mediator, have similar tasks, i.e. to approach the same data distribution generatively and predictively. The superiority of CoT over inconsistent methods like Scheduled Sampling is obvious, since CoT theoretically guarantees the training effectiveness. Compared with methods that require pre-training in order to reduce variance like SeqGAN (Yu et al., 2017), CoT is computationally cheaper. More specifically, under recommended settings, CoT has the same order of computational complexity as MLE. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            334
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides, CoT works independently. In practice, it does not require model pre-training via conventional methods like MLE. This is the first time that unbiased unsupervised learning is achieved on sequential discrete data without using supervised approximation for variance reduction or sophisticated smoothing as in Wasserstein GAN with gradient penalty (WGAN-GP) (Gulrajani et al., 2017). ",
+        "bbox": [
+            174,
+            340,
+            825,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4.2 THE NECESSITY OF THE MEDIATOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            477,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An interesting problem is to ask why we need to train a mediator by mixing the samples from both sources $G$ and $P$ , instead of directly training a predictive model $\\hat { P }$ on the training set via MLE. There are basically two points to interpret this. ",
+        "bbox": [
+            176,
+            436,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To apply the efficient training objective 13, one needs to obtain not only the mixture density model $M = { \\frac { 1 } { 2 } } { \\bar { ( P + G ) } }$ but also its decomposed form in each timestep i.e. $\\begin{array} { r } { \\dot { M } _ { \\phi } ( s ) = \\prod _ { t = 1 } ^ { n } M _ { \\phi } ( \\dot { s } _ { t } | s _ { t - 1 } ) } \\end{array}$ , without which the term $\\pi _ { m } ( s _ { t } )$ in Eq 13 cannot be computed efficiently. This indicates that if we directly estimate $P$ and compute $M { \\overset { \\cdot } { = } } { \\frac { 1 } { 2 } } ( G + P )$ , the obtained $M$ will be actually useless since its decomposed form is not available. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides, as a derivative problem of “exposure bias”, there is no guarantee for the model $\\hat { P }$ to work well on the generated samples i.e. $s \\sim G _ { \\theta }$ to guide the generator towards the target distribution. Given finite observations, the learned distribution $\\hat { P }$ is trained to provide correct predictions for samples from the target distribution $P$ . There is no guarantee that $\\hat { P }$ can stably provide correct predictions for guiding the generator. Ablation study is provided in the appendix. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            326,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 UNIVERSAL SEQUENCE MODELING IN SYNTHETIC TURING TEST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            666,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following the synthetic data experiment setting in (Yu et al., 2017; Zhu et al., 2018), we design a synthetic Turing test, in which the negative log-likelihood $\\mathrm { N L L } _ { o r a c l e }$ from an oracle LSTM is calculated for evaluating the quality of samples from the generator. Particularly, to support our claim that our method causes little mode collapse, we calculated $\\mathrm { N L L } _ { t e s t }$ , which is to sample an extra batch of samples from the oracle, and to calculate the negative log-likelihood measured by the generator. We show that under this more reasonable setting, our proposed algorithm reaches the state-of-the-art performance with exactly the same network architecture. Note that models like LeakGAN (Guo et al., 2017) contain architecture-level modification, which is orthogonal to our approach, thus will not be included in this part. The results are shown in Table 1. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            316,
+            871
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Computational Efficiency Although in terms of time cost per epoch, CoT does not achieve the state-of-the-art, we do observe that CoT is remarkably faster than previous RL-GAN approaches. Besides, consider the fact that CoT is a sample-based optimization algorithm, which involves time cost in sampling from the generator, this result is acceptable. The result also verifies our claim that CoT has the same order (i.e. the time cost only differs in a constant multiplier or extra lower order term) of computational complexity as MLE. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a216a60fed7003ed3625feeb3afef6f3a6825051ff76f4ad0226318c98952ed4.jpg",
+        "table_caption": [
+            "Table 1: Likelihood-based benchmark and time statistics for synthetic Turing test. ‘-(MLE)’ means the best performance is acquired during MLE pre-training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model/Algorithm</td><td>NLLoracle</td><td>NLLtest (final/best)</td><td>best NLLoracle+test</td><td>time/epoch</td></tr><tr><td>MLE</td><td>9.08</td><td>8.97/7.60</td><td>9.43 + 7.67</td><td>16.14 ± 0.97s</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>8.68</td><td>10.10/-(MLE)</td><td>(The same as MLE)</td><td>817.64 ± 5.41s</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>8.37</td><td>11.19/-(MLE)</td><td>(The same as MLE)</td><td>1270 ±13.01s</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>8.73</td><td>10.07/-(MLE)</td><td>(The same as MLE)</td><td>741.31 ± 1.45s</td></tr><tr><td>Scheduled Sampling (Bengio et al., 2015)</td><td>8.89</td><td>8.71/-(MLE)</td><td>(The same as MLE)</td><td>32.54 ± 1.14s</td></tr><tr><td>Professor Forcing (Lamb et al.,2016)</td><td>9.43</td><td>8.31/-(MLE)</td><td>(The same as MLE)</td><td>487.13 ± 0.95s</td></tr><tr><td>CoT (ours)</td><td>8.19</td><td>8.03/7.54</td><td>8.19 + 8.03</td><td>53.94 ± 1.01s</td></tr></table>",
+        "bbox": [
+            184,
+            141,
+            813,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0bb75bc9c49f9bc1d43ad68ca62b56d567fa7f08b651591185f7478be49faebe.jpg",
+        "image_caption": [
+            "Figure 2: Curves of evaluation on JSD, ${ \\mathrm { N L L } } _ { o r a c l e }$ during iterations of CoT under different training settings. To show the hyperparameter robustness of CoT, we compared it with the similar results as were evaluated in SeqGAN (Yu et al., 2017). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            262,
+            816,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            482,
+            825,
+            525
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameter Robustness. We perform a hyper-parameter robustness experiment on synthetic data experiment. When compared with the results of similar experiments as in SeqGAN (Yu et al., 2017), our approach shows less sensitivity to hyper-parameter choices, as shown in Figure 2. Note that since in all our attempts, the evaluated JSD of SeqGAN fails to converge, we evaluated NLLoracle for it as a replacement. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Self-estimated Training Progress Indicator. Like the critic loss, i.e. estimated Earth Mover Distance, in WGANs, we find that the training loss of the mediator (9), namely balanced NLL, can be a real-time training progress indicator as shown in Figure 3. Specifically, in a wide range, balanced NLL is a good estimation of real $J S D ( G \\| P )$ with a steady translation, namely, balanced $N L L =$ $J S D ( G \\| P ) + H ( G ) + H ( P )$ . ",
+        "bbox": [
+            173,
+            608,
+            825,
+            680
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/697f36a7c0a51aa15b14bd0d9a893b0db5dfe997b27792f1c6eb6462966c1892.jpg",
+        "image_caption": [
+            "Figure 3: (a) Curves of training time $J S D ( G \\| P )$ for MLE, SeqGAN and CoT. (b) Curves of balanced NLL and real JSD. Both results are from synthetic data experiments. Note that balanced NLL is considered to have only a constant translation of the estimated JSD by the mediator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            696,
+            813,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/03fed0fe2864b00b7f919f10713a2aa38c9ba724aab8a28612af08c7e6fe5650.jpg",
+        "table_caption": [
+            "Table 2: N-gram-level quality benchmark: BLEU on test data of EMNLP2017 WMT News "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model/Algorithm</td><td>BLEU-2</td><td>BLEU-3</td><td>BLEU-4</td><td>BLEU-5</td></tr><tr><td>MLE</td><td>0.781</td><td>0.482</td><td>0.225</td><td>0.105</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>0.731</td><td>0.426</td><td>0.181</td><td>0.096</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>0.691</td><td>0.387</td><td>0.178</td><td>0.095</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>0.755</td><td>0.456</td><td>0.179</td><td>0.088</td></tr><tr><td>LeakGAN (Guo et al., 2017)</td><td>0.835</td><td>0.648</td><td>0.437</td><td>0.271</td></tr><tr><td>TextCoT-basic (ours)</td><td>0.785</td><td>0.489</td><td>0.261</td><td>0.152</td></tr><tr><td>TextCoT-strong (ours)</td><td>0.800</td><td>0.501</td><td>0.273</td><td>0.200</td></tr><tr><td>TextCoT-strong (α = 1.5) (ours)</td><td>0.856</td><td>0.701</td><td>0.510</td><td>0.310</td></tr></table>",
+        "bbox": [
+            228,
+            127,
+            769,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/401981078f5a5ec29a021ec2e91a6bd2bb4a85d7007d77d644d9b14cfdcc9eed.jpg",
+        "table_caption": [
+            "Table 3: Diversity benchmark: estimated Word Mover Distance (eWMD) and $\\mathrm { N L L } _ { t e s t }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model/Algorithm</td><td>eWMDtest</td><td>eWMDtrain</td><td>NLLtest</td></tr><tr><td>MLE</td><td>1.015 (σ = 0.023)</td><td>0.947 (σ = 0.019)</td><td>2.365</td></tr><tr><td>SeqGAN (Yu et al., 2017)</td><td>2.900 (σ = 0.025)</td><td>3.118 (σ = 0.018)</td><td>3.122</td></tr><tr><td>RankGAN (Lin et al., 2017)</td><td>4.451 (σ = 0.083)</td><td>4.829 (σ = 0.021)</td><td>3.083</td></tr><tr><td>MaliGAN (Che et al., 2017)</td><td>4.891 (σ = :0.061)</td><td>4.962 (σ: 二 0.020)</td><td>3.240</td></tr><tr><td>LeakGAN (Guo et al., 2017)</td><td>1.803 (σ = 0.027)</td><td>1.767 (σ = ：0.023)</td><td>2.327</td></tr><tr><td>TextCoT-basic (ours)</td><td>0.766 (σ = 0.031)</td><td>0.886(σ = 0.019)</td><td>2.247</td></tr><tr><td>TextCoT-strong (ours)</td><td>0.923 (σ = 0.018)</td><td>0.941 (σ = 0.016)</td><td>2.144</td></tr></table>",
+        "bbox": [
+            217,
+            311,
+            781,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 TEXTCOT: ZERO-PRIOR LONG & DIVERSE TEXT GENERATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            650,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As an important sequential data modeling task, zero-prior text generation, especially long and diversified text generation, is a good testbed for evaluating the performance of a generative model. ",
+        "bbox": [
+            176,
+            496,
+            820,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following the experiment proposed in LeakGAN (Guo et al., 2017), we choose EMNLP 2017 WMT News Section as our dataset, with maximal sentence length limited to 51. We pay major attention to both quality and diversity. To keep the comparison fair, we present two implementations of CoT, namely CoT-basic and CoT-strong. As for CoT-basic, the generator follows the settings of that in MLE, SeqGAN, RankGAN and MaliGAN. As for CoT-strong, the generator is implemented with the similar architecture in LeakGAN. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For quality evaluation, we evaluated BLEU on a small batch of test data separated from the original dataset. For diversity evaluation, we evaluated the estimated Word Mover Distance (Kusner et al., 2015), which is calculated through training a discriminative model between generated samples and real samples with 1-Lipschitz constriant via gradient penalty as in WGAN-GP (Gulrajani et al., 2017). To keep it fair, for all evaluated models, the architecture and other training settings of the discriminative models are kept the same. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 2 and Table 3. In terms of generative quality, CoT-basic achieves state-of-the-art performance over all the baselines with the same architecture-level capacity, especially the long-term robustness at n-gram level. CoT-strong using a conservative generation strategy, i.e. setting the inverse temperature parameter $\\alpha$ higher than 1, as in (Guo et al., 2017) achieves the best performance over all compared models. In terms of generative diversity, the results show that our model achieves the state-of-the-art performance on all metrics including $\\mathrm { N L L } _ { t e s t }$ , which is the optimization target of MLE. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            809
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            318,
+            845
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We proposed Cooperative Training, a novel training algorithm for generative modeling of discrete data. CoT optimizes Jensen-Shannon Divergence, which does not have the exposure bias problem as the forward KLD. Models trained via CoT shows promising results in sequential discrete data modeling tasks, including sample quality and the generalization ability in likelihood prediction tasks. ",
+        "bbox": [
+            174,
+            861,
+            825,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky and Léon Bottou. Towards principled methods for training generative adversarial networks. arXiv preprint arXiv:1701.04862, 2017. ",
+        "bbox": [
+            176,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. arXiv:1701.07875, 2017. ",
+        "bbox": [
+            174,
+            162,
+            810,
+            178
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv:1409.0473, 2014. ",
+        "bbox": [
+            174,
+            186,
+            820,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In NIPS, pp. 1171–1179, 2015. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            253
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv:1702.07983, 2017. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016. ",
+        "bbox": [
+            173,
+            313,
+            826,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            349,
+            826,
+            380
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In NIPS, pp. 5769–5779, 2017. ",
+        "bbox": [
+            174,
+            387,
+            826,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiaxian Guo, Sidi Lu, Han Cai, Weinan Zhang, Yong Yu, and Jun Wang. Long text generation via adversarial training with leaked information. arXiv:1709.08624, 2017. ",
+        "bbox": [
+            173,
+            425,
+            823,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matt Kusner, Yu Sun, Nicholas Kolkin, and Kilian Weinberger. From word embeddings to document distances. In International Conference on Machine Learning, pp. 957–966, 2015. ",
+        "bbox": [
+            173,
+            462,
+            823,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex M Lamb, Anirudh Goyal ALIAS PARTH GOYAL, Ying Zhang, Saizheng Zhang, Aaron C Courville, and Yoshua Bengio. Professor forcing: A new algorithm for training recurrent networks. In NIPS, pp. 4601–4609, 2016. ",
+        "bbox": [
+            176,
+            500,
+            823,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for language generation. In NIPS, pp. 3155–3165, 2017. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sidi Lu, Yaoming Zhu, Weinan Zhang, Jun Wang, and Yong Yu. Neural text generation: Past, present and beyond. arXiv preprint arXiv:1803.07133, 2018. ",
+        "bbox": [
+            171,
+            588,
+            823,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015. ",
+        "bbox": [
+            171,
+            664,
+            823,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            178,
+            702,
+            825,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984. ",
+        "bbox": [
+            173,
+            752,
+            725,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016. ",
+        "bbox": [
+            171,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            843
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets with policy gradient. In AAAI, pp. 2852–2858, 2017. ",
+        "bbox": [
+            173,
+            852,
+            823,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaoming Zhu, Sidi Lu, Lei Zheng, Jiaxian Guo, Weinan Zhang, Jun Wang, and Yong Yu. Texygen: A benchmarking platform for text generation models. arXiv:1802.01886, 2018. ",
+        "bbox": [
+            174,
+            888,
+            825,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A DETAILED DERIVATION OF THE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            583,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd2df3dbdcd6f17e703eebbaa0c5e9657e046609ebf46b2592f109b58eeb236d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad = x _ { 1 } \\left( - \\frac { 1 } { 2 } \\sum _ { k _ { 1 } \\geq 0 } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } \\right) } \\\\ & { \\quad = - \\frac { 1 } { 2 } \\mathbb { E } \\left( \\sum _ { k _ { 1 } \\geq 0 } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } - 1 \\right) ^ { 2 } } \\\\ & { \\qquad - \\frac { 1 } { 2 } \\mathbb { E } \\left( \\sum _ { k _ { 1 } \\geq 0 } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } - 1 \\right) \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } } \\\\ & { \\qquad - \\frac { 1 } { 2 } \\mathbb { E } \\left( \\sum _ { k _ { 1 } \\geq 0 } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) \\partial _ { k - 1 } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } - 1 \\right) } \\\\ &  \\qquad - \\frac { 1 } { 2 } \\mathbb { E } \\left( \\sum _ { k _ { 1 } \\geq 0 } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } \\frac { \\partial _ { k } ( k _ { 1 } - 1 ) } { \\partial _ { k } ( k _ { 1 } - 1 ) } - 1 \\right) \\alpha ^ { 2 } \\beta \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\beta \\alpha ^ { 2 } \\beta \\alpha ^ { 2 } \\beta \\beta \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            198,
+            825,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B SAMPLE COMPARISON AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            531,
+            549,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows samples from some of the most powerful baseline models and our model. ",
+        "bbox": [
+            174,
+            564,
+            750,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Observation of the model samples indicates that: ",
+        "bbox": [
+            173,
+            585,
+            493,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• CoT produces remarkably more diverse and meaningful samples when compared to LeakGAN. • The consistency of CoT is significantly improved when compared to MLE. ",
+        "bbox": [
+            215,
+            612,
+            825,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C FURTHER DISCUSSIONS ABOUT THE EXPERIMENT RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            705,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The Optimal Balance for Cooperative Training We find that the same learning rate and iteration numbers for the generator and mediator seems to be the most competitive choice. As for the architecture choice, we find that the mediator needs to be slightly stronger than the generator. For the best result in the synthetic experiment, we adopt exactly the same generator as other compared models and a mediator whose hidden state size is twice larger (with 64 hidden units) than the generator. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theoretically speaking, we can and we should sample more batches from $G _ { \\theta }$ and $P$ respectively for training the mediator in each iteration. However, if no regularizations are used when training the mediator, it can easily over-fit, leading the generator’s quick convergence in terms of $K L ( G _ { \\theta } | | P )$ or ${ \\mathrm { N L L } } _ { o r a c l e }$ , but divergence in terms of $J S D ( G _ { \\theta } \\| P )$ . Empirically, this could be alleviated by applying dropout techniques (Srivastava et al., 2014) with $50 \\%$ keeping ratio before the output layer of RNN. After applying dropout, the empirical results show good consistency with our theory that, more training batches for the mediator in each iteration is always helpful. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "However, applying regularizations is not an ultimate solution and we look forward to further theoretical investigation on better solutions for this problem in the future. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/96277b004ab0fc26f37d108f124b85bf9167b3c804feeee9eab369a467f05ffa.jpg",
+        "table_caption": [
+            "Table 4: WMT News Samples from Different Models "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Sources</td><td rowspan=1 colspan=1>Example</td></tr><tr><td rowspan=1 colspan=1>LeakGAN</td><td rowspan=1 colspan=1>(1) It&#x27;s a big advocate for therapy is a second thing to do, and I&#x27;m creating a relationshipwith a nation.(2) It&#x27;s probably for a fantastic footage of the game,but in the United States is alreadytime to be taken to live.(3) It&#x27;s a sad House we have a way to get the right because we have to go to see that,” shesaid.(4)I&#x27;m not sure if I thank a litle bit easier to get to my future commitment in work,”hesaid.(5)“I think it was alone because Ican do that, when you&#x27;re a lot of reasons,”he said.(6) It&#x27;s the only thing we do,we spent 26 and $35(see how you do is we lose it,” said bothsides in the summer.</td></tr><tr><td rowspan=1 colspan=1>CoT</td><td rowspan=1 colspan=1>(1) We focus the plans to put aside either now,and which doesn&#x27;t mean it is to earn theimpact to the government rejected.(2) The argument would be very doing work on the 2O14 campaign to pursue the firm andimmigration officials,the new review that’s taken up for parking.(3) This method is true to available we make up drink with that all they were willing topay down smoking.(4) The number of people who are on the streaming boat would study if the children had abottle - but meant to be much easier,having serious ties to the outside of the nation.(5)However,they have to wait to get the plant in federal fees and the housing market&#x27;smost valuable in tourism.</td></tr><tr><td rowspan=1 colspan=1>MLE</td><td rowspan=1 colspan=1>(1) after the possible cost of military regulatory scientists,chancellor angela merkel&#x27;sbusiness share together a conflict of major operators and interest as they said it is unknownfor those probably1OO percent as a missile for britain.(2) but which have yet to involve the right climb that took in melbourne somewhere elsewith the rams even a second running mate and kansas.(3)“la la la la 3O who appeared that themselves is in the room when they were shot heruntil the end ”that jose mourinho could risen from the individual .(4) when aaron you has died,it is thought if you took your room at the prison fines ofradical controls by everybody, if it&#x27;s a digital plan at an future of the next time.</td></tr></table>",
+        "bbox": [
+            186,
+            128,
+            807,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Possible Derivatives of CoT The form of equation 13 can be modified to optimize other objectives. One example is the backward KLD (a.k.a. Reverse KLD) i.e. $K L ( G \\| P )$ . In this case, the objective of the so-called “Mediator” and “Generator” thus becomes: ",
+        "bbox": [
+            174,
+            546,
+            825,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "“Mediator”, now it becomes a direct estimator $\\hat { P } _ { \\phi }$ of the target distribution $P$ : ",
+        "bbox": [
+            173,
+            594,
+            678,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/188cd3ec7d1ac80cceaddcc34d47521192b18ba9e0aee430005e62c5e3d8d672.jpg",
+        "text": "$$\nJ _ { \\hat { p } } ( \\phi ) = \\underset { s \\sim P } { \\mathbb { E } } [ - \\log ( \\hat { P } _ { \\phi } ( s ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            617,
+            596,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Generator: ",
+        "bbox": [
+            173,
+            659,
+            245,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a947d2784e9e6511d8c64419dcfc2d6db485e936aa83ba6850f589d6a4ed087.jpg",
+        "text": "$$\n\\nabla _ { \\boldsymbol { \\theta } } J _ { g } ( \\boldsymbol { \\theta } ) = \\nabla _ { \\boldsymbol { \\theta } } \\underset { s \\sim G _ { \\boldsymbol { \\theta } } } { \\mathbb { E } } \\Big [ \\sum _ { t = 0 } ^ { n - 1 } \\pi _ { g } ( s _ { t } ) ^ { \\top } ( \\log \\pi _ { \\hat { p } } ( s _ { t } ) - \\log \\pi _ { g } ( s _ { t } ) ) \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            669,
+            705,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Such a model suffers from so-called mode-collapse problem, as is analyzed in Ian’s GAN Tutorial (Goodfellow, 2016). Besides, as the distribution estimator $\\hat { P } \\phi$ inevitably introduces unpredictable behaviors when given unseen samples i.e. samples from the generator, the algorithm sometimes fails (numerical error) or diverges. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In our successful attempts, the algorithm produces similar (not significantly better than) results as CoT. The quantitive results are shown as follows: ",
+        "bbox": [
+            173,
+            786,
+            823,
+            815
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b8fe834db5f2de7cf570597bb58fa9e8fd13cdac25fd3edea8d97fec8a25721.jpg",
+        "table_caption": [
+            "Table 5: N-gram-level quality benchmark: BLEU on test data of EMNLP2017 WMT News (New Split) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model/Algorithm</td><td>BLEU-2</td><td>BLEU-3</td><td>BLEU-4</td><td>BLEU-5</td><td>eWMD</td></tr><tr><td>CoT-basic (ours)</td><td>0.850</td><td>0.571</td><td>0.316</td><td>0.169</td><td>1.001 (σ = 0.020)</td></tr><tr><td>Reverse KL (ours)</td><td>0.860</td><td>0.590</td><td>0.335</td><td>0.181</td><td>1.086 (σ = 0.014)</td></tr></table>",
+        "bbox": [
+            227,
+            867,
+            769,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Although under evaluation of weak metrics like BLEU, if successfully trained, the model trained via Reverse KL seems to be better than that trained via CoT, the disadvantage of Reverse KL under evaluation of more strict metric like eWMD indicates that Reverse KL does fail in learning some aspects of the data patterns e.g. completely covering the data mode. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ryCM8zWRb/ryCM8zWRb.md

@@ -0,0 +1,259 @@
+# RECURRENT NEURAL NETWORKS WITH TOP-K GAINS FOR SESSION-BASED RECOMMENDATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+RNNs have been shown to be excellent models for sequential data and in particular for session-based user behavior. The use of RNNs provides impressive performance benefits over classical methods in session-based recommendations. In this work we introduce a novel ranking loss function tailored for RNNs in recommendation settings. The better performance of such loss over alternatives, along with further tricks and improvements described in this work, allow to achieve an overall improvement of up to $3 5 \%$ in terms of MRR and Recall $\textcircled{ a} 2 0$ over previous session-based RNN solutions and up to $51 \%$ over classical collaborative filtering approaches. Unlike data augmentation-based improvements, our method does not increase training times significantly.
+
+# 1 INTRODUCTION
+
+Session-based recommendation is a very common recommendation problem that is encountered in many domains such as e-commerce, classified sites, music and video recommendation. In the session-based setting, past user history logs are typically not available (either because the user is new or not logged-in or not tracked) and recommender systems have to rely only on the actions of the user in the current sessions to provide accurate recommendations. Until recently many of these recommendations tasks were tackled mainly using relatively simple methods such as item-based collaborative filtering (Sarwar et al., 2001) or content-based methods. Recurrent Neural Networks (RNNs) have emerged from the deep learning literature as powerful methods for modeling sequential data. These models have been successfully applied in speech recognition, translation, time series forecasting and signal processing. In recommender systems RNNs have been recently applied to the session-based recommendation setting with impressive results (Hidasi et al., 2016a).
+
+The advantage of RNNs over traditional similarity-based methods for recommendation is that they can effectively model the whole session of user interactions (clicks, views, etc.). By modeling the whole session RNNs can in effect learn the ‘theme’ of the session and thus provide recommendations with increased accuracy (between $2 0 \% { - } 3 0 \%$ ) over traditional methods.
+
+RNNs in session-based recommendation have been adapted to the task of recommendation. One of the main objectives in recommendation is to rank items by user preference; i.e. the exact ranking or scoring of items in the tail of the item list (items that the user will not like) is not that important, but it is very important to rank correctly the items that the user will like at the top of the list (first 5, 10 or 20 positions). To achieve this with machine learning one has to typically utilize learning to rank techniques(see e.g. (Burges, 2010)) and in particular ranking objectives and loss functions. The current session-based RNN approaches use ranking loss functions and, in particular, pairwise ranking loss functions. As in most deep learning approaches the choice of a good ranking loss can have a very significant influence on performance. Since deep learning methods need to propagate gradients over several layers and in the case of RNNs ’back in time’ over previous steps, to optimize the model parameters, the quality of these gradients originating from the loss function influences the quality of the optimization and the model parameters. Moreover the nature of the recommendation task, which typically entails large output spaces (due to large number of items), poses unique challenges that have to be taken into account as well when designing a proper ranking loss function. We will see that the way this large output space issue is tackled is very crucial in achieving good performance.
+
+In this work we analyze ranking loss functions used in RNNs for session-based recommendations, this analysis leads to a new set of ranking loss functions that increase the performance of the RNN up to $30 \%$ over previous commonly used losses without incurring in significant computational overheads. We essentially devise a new class of loss functions that combines learnings from the deep learning and the learning to rank literature. Experimental results on several datasets coming from industry validate these impressive improvements, in terms of Mean Reciprocal Rank (MRR) and Recall $\textcircled{ a} 2 0$ . With these improvements the difference between RNNs and conventional memory-based collaborative filtering jumps to $51 \%$ in terms of MRR and Recall $\textcircled{ a} 2 0$ demonstrating the potential that deep learning methods bring to the area of Recommender Systems.
+
+# 1.1 RELATED WORK
+
+One of the main approaches that is employed in session-based recommendation and a natural solution to the problem of a missing user profile is the item-to-item recommendation approach (Sarwar et al., 2001; Linden et al., 2003). In this setting, an item-to-item similarity matrix is precomputed from the available session data, that is items that are often clicked together in sessions are deemed to be similar. This similarity matrix is then simply used during the session to recommend the most similar items to the one the user has currently clicked.
+
+Long Short-Term Memory (LSTM) Hochreiter & Schmidhuber (1997) networks are a type of RNNs that have been shown to solve the optimization issues the plague vanilla-type RNNs. LSTM’s include additional gates that regulate when and how much of the input to take into account and when to reset the hidden state. A slightly simplified version of LSTM – that still maintains all their properties – are Gated Recurrent Units (GRUs) Cho et al. (2014), which we use in this work. Recurrent Neural Networks have been used with success in the area of session-based recommendations; (Hidasi et al., 2016a) proposed a Recurrent Neural Network with a pairwise ranking loss for this task, (Tan et al., 2016) proposed data augmentation techniques to improve the performance of the RNN for session-based recommendations; these techniques have though the side effect of increasing training times as a single session is split into several sub-sessions for training. Session-based RNNs have been augmented (Hidasi et al., 2016b) with feature information, such as text and images from the clicked/consumed items, showing improved performance over the plain models. RNNs have also been used in more standard user-item collaborative filtering settings where the aim is to model the evolution of the user and items factors (Wu et al., 2017),(Devooght & Bersini, 2016) where the results are less striking, with the proposed methods barely outperforming standard matrix factorization methods. This is to be expected as there is no strong evidence on major user taste evolution in a single domain in the timeframes of the available datasets and sequential modeling of items that are not ’consumed’ in sessions such as movies might not bring major benefits.
+
+Another area touched upon in this work are loss functions tailored to recommender systems requirements. This typically means ranking loss functions. In this area there has been work particularly in the context of matrix factorization techniques. One of the first learning to rank techniques for collaborative filtering was introduced in (Weimer et al., 2007). Essentially a listwise loss function was introduced along with an alternating bundle method for optimization of the factors. Further ranking loss function for collaborative filtering were introduced in (Shi et al., 2012) (Rendle et al., 2009b) and (Koren & Sill, 2011). Note that the fact that these loss functions work well in matrix factorization does not guarantee in any way that they are an optimal choice for RNNs as backpropagation requirements are stronger than those posed by simple SGD. We will in fact see that BPR, a popular choice of loss function, needs to be significantly modified to extract optimal results in the case of RNNs for session-based recommendations. Another work related to sampling large output spaces in deep networks for efficient loss computations for language models is the ’blackout’ method (Ji et al., 2016), where essentially a sampling procedure similar to the one used in (Hidasi et al., 2016a) is applied in order to efficiently compute the categorical cross-entropy loss.
+
+# 2 SAMPLING THE OUTPUT
+
+In the remainder of the paper we will refer to the RNN algorithm implemented in (Hidasi et al., 2016a) as GRU4Rec, the name of the implementation published by the authors on github 1. In this section we revisit how GRU4Rec samples negative feedback on the output and discuss its importance. We extend this sampling with an option for additional samples and argue that this is crucial for the increased recommendation accuracy we achieve (up to $51 \%$ improvement).
+
+In each training step, GRU4Rec takes the item of the current event in the session – represented by a one-hot vector – as an input. The output of the network is a set of scores over the items, corresponding to their likelihood of being the next item in the session. The training iterates through all events in the sequence. The complexity of the training with backpropagation through time is $O ( N _ { E } ( H ^ { 2 } + H { N _ { O } } ) )$ where $N _ { E }$ is the number of training events, $H$ is the number of hidden units and $N _ { O }$ is the number of outputs, for which scores are computed. Computing scores for all items is very impractical, since it makes the network unscalable2. Therefore GRU4Rec uses a sampling mechanism and during training computes the scores for a subset of the items only.
+
+Instead of making a forward and backward pass with one training example only and then moving to the next, the network is fed with a bundle of examples and is trained on the mean gradient. This common practice is called mini-batch training and has several benefits, e.g. utilizing the parallelization capabilities of current hardware better, thus training faster, and producing more stable gradients than stochastic gradient training and thus converging faster. GRU4Rec introduced mini-batch based sampling Hidasi et al. (2016a). For each example in the mini-batch, the other examples of the same mini-batch serve as negative examples (see Figure 1).3 This method is practical from an implementation point of view and can be also implemented efficiently for GPUs.
+
+![](images/b301f02dce3fe8cdc0e08469fa25de3bdd5edc2f9a32fb1f015357edca0546ec.jpg)  
+Figure 1: Mini-batch sampling.
+
+The network can be trained with one of three different listwise ranking loss functions (see Section 3). All loss functions require a score for the target item (i.e. for the item which was the actual next item) and score(s) for at least one negative sample (i.e. item other than the target). One property of ranking losses is that learning happens only if the score of the target item does not exceed that of the negative samples by a large margin, otherwise the items are already in the right order, so there is nothing to be learned. Therefore, when utilizing a sampling procedure, it is crucial that high scoring items make it among the negative samples. Whether an item has a high score, depends on the context (item sequence) the scores are actually computed for. Popular items generally score high in many situations, making popularity-based sampling a good sampling strategy. Mini-batch sampling is basically a form of popularity-based sampling, since the training iterates through all events, thus the probability of an item acting as a negative sample is proportional to its support. The problem with popularity-based sampling is that learning can slow down after the algorithm learns to (generally) rank target items above popular ones, and thus can still be inaccurate with ranking long tail high scoring items. On the other hand, uniform sampling slows down learning, due to the high number of low scoring negative samples, but might produce an overall more accurate model if trained indefinitely. In our experience, popularity-based sampling generally produces better results.
+
+Tying sampling to the mini-batches has several practical benefits, but is too restrictive for three reasons. (1) Mini-batch sizes are generally small, ranging from few tens to few hundreds. If the number of items is large, the small sample size further hinders the chance of including all of the high scoring negative examples. (2) Mini-batch size has a direct effect on the training. E.g. we found that training with smaller mini-batch sizes (30-100) produces more accurate models, but training with larger ones is faster on the GPU due to parallelization. (3) The sampling method is inherently popularity-based, which generally is a good strategy, but might not be optimal for all datasets.
+
+Therefore we extend the sampling of GRU4Rec with additional samples. We sample $N _ { A }$ items which are shared by the examples of the mini-batch, i.e. the same samples are used for each exam$\mathrm { p l e } ^ { 4 }$ . These additional samples are used along with the $N _ { B } - 1$ samples coming from the mini-batch (popularity) sampling. Additional samples can be sampled in any way, we chose to sample proportional to $\mathrm { s u p p } _ { i } ^ { \alpha }$ , where ${ \mathrm { s u p p } } _ { i }$ is the support of the item and $\alpha$ is the parameter of the sampling. $\alpha = 0$ and $\alpha = 1$ gives uniform and popularity-based sampling respectively.
+
+Adding more samples naturally increases the complexity, since $N _ { O }$ increases from $N _ { B }$ to $N _ { A } + N _ { B }$ . However, the computations are easily parallelizable, thus there is no actual increase in the training time on modern GPUs up to a certain sample size (see Section 4.1). The efficient implementation of this sampling however is not trivial. Sampling according to a distribution on GPUs is slow, thus it should be handled by the CPU. The sampled item IDs can be given to the GPU along with the item IDs of the mini-batch. Sampling the distribution takes some time every time a new minibatch is formed, thus GPU execution is frequently interrupted, making GPU utilization low and thus training slow. On the top of that, sampling a few items at once is less efficient than sampling lots of them, even on CPU. Therefore we implemented a cache that pre-samples and stores lots of negative samples. Training uses up these samples and the cache is recomputed once it is empty. We found that pre-sampling 10-100 million item IDs significantly improves training speed when compared to using no cache at all.
+
+# 3 LOSS FUNCTION DESIGN
+
+In this section we examine the loss functions implemented in GRU4Rec and identify their weaknesses. We propose two ways to stabilize the numerical instability of the cross-entropy loss, we show how learning with the TOP1 and BPR pairwise losses degrades as we add more samples to the output, and propose a family of loss functions based on pairwise losses that alleviates this problem. We note that, while our aim is to improve GRU4Rec, the loss functions proposed in this section can be also used with other models, such as matrix factorization.
+
+# 3.1 CATEGORICAL CROSS-ENTROPY
+
+Categorical cross-entropy measures the distance of a proposed (discrete) probability distribution $q$ from the target distribution $p$ as defined by (1).
+
+$$
+H ( p , q ) = - \sum _ { j = 1 } ^ { N } p _ { j } \log q _ { j }
+$$
+
+This loss is often used in machine learning and deep learning in particular for multi-class classification problems. Next item recommendation can be interpreted as classification, where the class labels are the items in the system and item sequences need to be assigned with the label of the item that follows. In a single-label scenario – such as next item recommendation – the target distribution is a one-hot vector over the set of items, with the coordinate corresponding to the target item set to 1. The proposed distribution consists of the scores assigned to the items by the algorithm. The output scores need to be transformed to form a distribution. It is common practice to use the softmax transformation (2), which is a continuous approximation of the max operation. This naturally aligns with the sentiment that the label with the highest score is assigned to the sequence.
+
+$$
+s _ { i } = \frac { e ^ { r _ { i } } } { \sum _ { j = 1 } ^ { N } e ^ { r _ { j } } }
+$$
+
+Cross-entropy in itself is a pointwise loss, (that is it can be computed per individual item) as it is the sum of independent losses defined over the coordinates. Combining it with softmax introduces listwise properties into the loss, since the loss now cannot be separated over coordinates (or items). Putting them together we get the following loss function over the scores (assuming that the target item is indexed by $i$ ):
+
+$$
+L _ { \mathrm { x e } } = - \log s _ { i } = - \log \frac { e ^ { r _ { i } } } { \sum _ { j = 1 } ^ { N } e ^ { r _ { j } } }
+$$
+
+Fixing the instability: One of the losses available in GRU4Rec was cross-entropy with softmax scores. Hidasi et al. (2016a) reported slightly better results than with other losses, but deemed the loss to be unstable for a large fraction of the hyperparameter space and thus advised against its use. This instability comes from the limited numerical precision. Assuming that there is a $k$ for which $r _ { k } \gg r _ { i }$ , $s _ { i }$ becomes very small and rounded to 0, because of the limited precision. The loss then computes $\log 0$ , which is undefined. Two ways to circumvent this problem are as follow: (a) compute $- \log ( s _ { i } + \epsilon )$ , where $\epsilon$ is a very small value (we use $1 0 ^ { - 2 4 }$ ); (b) compute $- \log s _ { i }$ directly as $\textstyle - r _ { i } + \log \sum _ { j = 1 } ^ { N } e ^ { r _ { j } }$ . The former introduces some noise, while the latter does not allow the separated use of the transformation and the loss, but both methods stabilize the loss. We did not observe any differences in the results of the two variants.
+
+# 3.2 RANKING LOSSES: TOP1 & BPR
+
+GRU4Rec offers two loss functions based on pairwise losses. Pairwise losses compare the score of the target to a negative example (i.e. any item other than the target). The loss is high if the target’s score is higher than that of the negative example. GRU4Rec computes scores for multiple negative samples per each target, and thus the loss function is composed as the average of the individual pairwise losses. This results in a listwise loss function, which is composed of pairwise losses.
+
+One of the loss functions is coined TOP1 (4). It is a heuristically put together loss consisting of two parts. The first part aims to push the target score above the score of the samples, while the second part lowers the score of negative samples towards zero. The latter acts as a regularizer, but instead of constraining the model weights directly, it penalizes high scores on the negative examples. Since all items act as a negative score in one training example or another, it generally pushes the scores down.
+
+$$
+L _ { \mathrm { t o p 1 } } = \frac { 1 } { N _ { S } } \sum _ { j = 1 } ^ { N _ { S } } \sigma ( r _ { j } - r _ { i } ) + \sigma ( r _ { j } ^ { 2 } )
+$$
+
+$j$ runs over the $( N _ { S } )$ sampled negative (’non-relevant’) items, relevant items are index by $i$ . The other loss function (5) is based on the popular Bayesian Personalized Ranking (BPR) Rendle et al. (2009a) loss. Here the negative log-probability of the target score exceeding the sample scores is minimized (i.e. the probability of target scores being above sample scores is maximized). The non-continuous $P ( r _ { i } > r _ { j } )$ is approximated by $\sigma ( r _ { i } - r _ { j } )$ .
+
+$$
+L _ { \mathrm { b p r } } = - \frac { 1 } { N _ { S } } \sum _ { j = 1 } ^ { N _ { S } } \log \sigma ( r _ { i } - r _ { j } )
+$$
+
+# 3.2.1 VANISHING GRADIENTS
+
+Taking the average of individual pairwise losses has an undesired side effect. Examining the gradients for the TOP1 and BPR losses w.r.t. the target score $r _ { i }$ , ((6) and (7) respectively) reveals that under certain circumstances gradients vanish and thus learning stops. With pairwise losses, one generally wants to have negative samples with high scores, as those samples produce high gradients. Or intuitively, if the score of the negative sample is already well below that of the target, there is nothing to learn from that negative sample anymore. For this discussion we will denote samples where $r _ { j } \ \ll \ r _ { i }$ irrelevant. For an irrelevant sample $\sigma ( r _ { j } \mathrm { ~ - ~ } r _ { i } )$ in ((6) and $1 - \sigma ( r _ { i } - r _ { j } )$ (7)
+
+will be close to zero. Therefore, any irrelevant sample adds basically nothing to the total gradient. Meanwhile the gradient is always discounted by the total number of negative samples. By increasing the number of samples, the number of irrelevant samples increases faster than that of including relevant samples, since the majority of items is irrelevant as a negative sample. This is especially true for non-popularity-based sampling and high sample numbers. Therefore these losses start to vanish as the number of samples increase, which is counterintuitive and hurts the full potential of the algorithm.56
+
+$$
+\frac { \partial L _ { \mathrm { t o p 1 } } } { \partial r _ { i } } = - \frac { 1 } { N _ { S } } \sum _ { j = 1 } ^ { N _ { S } } \sigma ( r _ { j } - r _ { i } ) \left( 1 - \sigma ( r _ { j } - r _ { i } ) \right)
+$$
+
+$$
+\frac { \partial L _ { \mathrm { b p r } } } { \partial r _ { i } } = - \frac { 1 } { N _ { S } } \sum _ { j = 1 } ^ { N _ { S } } \left( 1 - \sigma ( r _ { i } - r _ { j } ) \right)
+$$
+
+Note, that TOP1 is sensitive to relevant examples where $r _ { j } \gg r _ { i }$ , which is an oversight in the design of the loss. While this is unlikely to happen, it cannot be outruled. For example, when comparing a niche target to a very popular sample – especially during the early phase of learning – the target score might be much lower than the sample score.
+
+We concentrated on the gradients w.r.t. the target score, but a similar issue can be observed for the gradients on the negative scores. The gradient w.r.t. the score of a negative sample is the gradient of the pairwise loss between the target and the sample divided by the number of negative samples. This means that even if all negative samples would be relevant, their updates would still diminish as their number grows.
+
+![](images/3e39714c3915770892e4cac5001816899b5434c82313e30bf2c08752cc04ff57.jpg)  
+Figure 2: Median negative gradients of BPR and BPR-max w.r.t. the target score against the rank of the target item. Left: only minibatch samples are used (minibatch size: 32); Center: 2048 additional negative samples were added to the minibatch samples; Right: same setting as the center, focusing on ranks 0-200.
+
+# 3.3 RANKING-MAX LOSS FUNCTION FAMILY
+
+To overcome the vanishing of gradients as the number of samples increase, we propose a new family of listwise loss functions, based on individual pairwise losses. The idea is to have the target score compared with the most relevant sample score, which is the maximal score amongst the samples. The general structure of the loss is described by (8).
+
+$$
+L _ { \mathrm { p a i r w i s e - m a x } } \left( r _ { i } , \{ r _ { j } \} _ { j = 1 } ^ { N _ { S } } \right) = L _ { \mathrm { p a i r w i s e } } ( r _ { i } , \operatorname* { m a x } _ { j } r _ { j } )
+$$
+
+The maximum selection is non-differentiable and thus cannot be used with gradient descent. Therefore we use the softmax scores to preserve differentiability. Here, the softmax transformation is only used on the negative examples (i.e. $r _ { i }$ is excluded), since we are looking from the maximum score amongst the negative examples. This naturally results in loss functions where each negative sample is taken into account proportional to its likelihood of having the maximal score. Based on this general idea, we now derive the TOP1-max and BPR-max loss functions.
+
+TOP1-max: The TOP1-max loss is fairly straightforward. The regularizing part does not necessarily need to be only applied for the maximal negative score, however we found that this gave the best results, thus kept it this way. The continuous approximation to the maximum selection entails summing over the individual losses weighted by the corresponding softmax scores $s _ { j }$ , giving us the TOP1-max loss (9).
+
+$$
+L _ { \mathrm { t o p 1 - m a x } } = \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \left( \sigma ( r _ { j } - r _ { i } ) + \sigma ( r _ { j } ^ { 2 } ) \right)
+$$
+
+The gradient of TOP1-max (10) is the softmax weighted average7 of individual pairwise gradients. If $r _ { j }$ is much lower than the maximum of negative scores, its weight will be almost zero and more weight will be placed on examples with scores close to the maximum. This solves the issue of vanishing gradients with more samples, because irrelevant samples will be just ignored, while the gradient will point towards the gradient of the relevant samples. Of course, if all samples are irrelevant, the gradient becomes near zero, but this is not a problem, since if the target score is greater than all sample scores, there is nothing to be learned. Unfortunately, the sensitivity to large sample scores of TOP1 is still an issue as it is the consequence of the pairwise loss and not the aggregation.
+
+$$
+\frac { \partial L _ { \mathrm { t o p 1 - m a x } } } { \partial \boldsymbol { r } _ { i } } = - \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma ( \boldsymbol { r } _ { j } - \boldsymbol { r } _ { i } ) \left( 1 - \sigma ( \boldsymbol { r } _ { j } - \boldsymbol { r } _ { i } ) \right)
+$$
+
+BPR-max: Going back to the probability interpretation of BPR, the goal is to maximize the probability of the target score being higher than the maximal sample score $r _ { \operatorname* { m a x } } = \operatorname* { m a x } _ { j } r _ { j }$ . This can be rewritten using conditional probabilities:
+
+$$
+P ( r _ { i } > r _ { \operatorname* { m a x } } ) = \sum _ { j = 1 } ^ { N _ { S } } P ( r _ { i } > r _ { j } | r _ { j } = r _ { \operatorname* { m a x } } ) P ( r _ { j } = r _ { \operatorname* { m a x } } )
+$$
+
+$P ( r _ { i } > r _ { j } )$ and $P ( r _ { j } = r _ { \operatorname* { m a x } } )$ is approximated by $\sigma ( r _ { i } - r _ { j } )$ (as in the original BPR loss) and the softmax score $s _ { j }$ respectively. We then want to minimize the negative log-probability, which gives us the loss:
+
+$$
+L _ { \mathrm { b p r - m a x } } = - \log \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma ( r _ { i } - r _ { j } )
+$$
+
+The gradient of BPR-max (13) is the weighted average of individual BPR gradients, where the weights are $s _ { j } \sigma ( r _ { i } - r _ { j } )$ . The relative importance of negative samples $j$ and $k$ is $\begin{array} { r } { \frac { \sigma ( r _ { i } - r _ { j } ) s _ { j } } { \sigma ( r _ { i } - r _ { k } ) s _ { k } } = } \end{array}$ erj +e−ri+rj+rkerk +e−ri+rj+rk , which behaves like softmax weights if ri  rj + rk or if both ri and rk are small. Otherwise it is a smoothed softmax. This means that while $r _ { i }$ is small, the weights are distributed more evenly, yet clear emphasis will be given to higher sample scores. As $r _ { i }$ becomes higher, the focus shifts quickly to the samples with high scores. This is an ideal behaviour.
+
+$$
+\frac { \partial L _ { \mathrm { b p r - m a x } } } { \partial \boldsymbol { r } _ { i } } = - \frac { \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma \big ( \boldsymbol { r } _ { i } - \boldsymbol { r } _ { j } \big ) \left( 1 - \sigma \big ( \boldsymbol { r } _ { i } - \boldsymbol { r } _ { j } \big ) \right) } { \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma \big ( \boldsymbol { r } _ { i } - \boldsymbol { r } _ { j } \big ) }
+$$
+
+The gradient w.r.t. a negative sample – with both the BPR-max and TOP1-max – is proportional to the softmax score of the example, meaning that only the items, near the maximum will be updated. This is beneficial, because if the score of a negative sample is low, it doesn’t need to be updated. If the score of a sample is much higher than that of the others it will be the only one updated and the gradient will coincide with the gradient of the pairwise loss between the target and the sample score. In a more balanced setting the gradient is between the aforementioned gradient and 0. For example the gradient of BPR-max w.r.t. a negative sample’s score is as follows:
+
+$$
+\frac { \partial L _ { \mathrm { b p r - m a x } } } { \partial \boldsymbol { r } _ { k } } = s _ { k } - \frac { s _ { k } \sigma ^ { 2 } ( \boldsymbol { r } _ { i } - \boldsymbol { r } _ { k } ) } { \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma ( \boldsymbol { r } _ { i } - \boldsymbol { r } _ { j } ) }
+$$
+
+Figure 2 depicts how the gradients of BPR and BPR-max behave given the rank of the target item8. The rank of the target is the number of negative scores exceeding it, e.g. rank 0 means that the target score is higher than all sample scores. Lower rank means that there are fewer negative samples that are relevant. The figure depicts the median negative gradient w.r.t. the target score in two cases, measured on a dataset sample during the $1 ^ { s t }$ and $1 0 ^ { t h }$ epochs (i.e. beginning and end of the training): (left) no additional samples were used, only the other examples from a mini-batch of size 32; (middle & right) 2048 additional negative samples were added. The rightmost figure focuses on the first 200 ranks of the figure in the middle. The gradient is slightly higher for BPR when there are more relevant samples (i.e. high ranks). This is natural, since BPR-max focuses on samples closest to the maximum value and ignores other still relevant samples. This entails slightly slower learning for BPR-max when the target item is ranked at the end of the list, but the difference is not really significant. On the other hand, the gradient of BPR quickly vanishes as the number of relevant samples decrease (i.e. low ranks). The point of vanishing is relative to the total sample size. With small sample size, BPR’s gradient starts vanishing around rank 5 (the BPR-max does not vanish until rank 0); meanwhile, with more samples, the BPR gradient is very low, even for rank 100-500 (again, the gradient BPR-max starts decreasing significantly later). This means that BPR can hardly push target scores up in the ranking after a certain point, which comes earlier as the number of sample size increases. BPR-max, on the other hand, behaves well and is able to improve the score all the way.
+
+# 3.3.1 BPR-MAX WITH SCORE REGULARIZATION
+
+Even though we showed that the heuristic TOP1 loss is sensitive to relevant samples with very high scores, it was found to be performing better than BPR in Hidasi et al. (2016a). According to our observation, the same is true for the relation of TOP1-max and BPR-max. Part of the reasons lies in the rare occurrence of $r _ { j } \gg r _ { i }$ while $r _ { j } \approx 0$ simultaneously. If only the first condition is met, the gradient w.r.t. $r _ { i }$ might vanish, but the regularizing part of TOP1 makes sure that $r _ { j }$ is moved towards zero, which might even make the update possible for $r _ { i }$ next time (e.g. if $r _ { j }$ was negative, moving it towards zero decreases the difference with $r _ { i }$ ). The score regularization in TOP1 is very beneficial to the overall learning process, so even though the loss might not be theoretically optimal, it can achieve good results. GRU4Rec support two forms of regularization with every loss: dropout and $\ell _ { 2 }$ regularization of the model parameters. The regularization of TOP1 is used on the top of these. According to our experiments, the $\ell _ { 2 }$ regularization of model parameters decreases the model performance. Our assumption is that some of the model weights – such as the weight matrices for computing the update and reset gate – should not be regularized. Penalizing high output scores takes care of constraining the model, even without explicitly regularizing the weights.
+
+Therefore we added score regularization to the BPR-max loss function as well. We tried several ways of score regularization. In the best performing one we conditioned the sample scores on independent, zero mean Gaussians with variance inversely proportional to the softmax score (15). This entails stronger regularization on scores closer to the maximum, which is ideal in our case.
+
+$$
+P \left( r _ { i } > r _ { \mathrm { m a x } } | \{ r _ { j } \} _ { j = 1 } ^ { N _ { S } } \right) \prod _ { j = 1 } ^ { N _ { S } } P ( r _ { j } ) = P \left( r _ { i } > r _ { \mathrm { m a x } } | \{ r _ { j } \} _ { j = 1 } ^ { N _ { S } } \right) \prod _ { j = 1 } ^ { N _ { S } } \mathcal { N } \left( 0 , \frac { c } { s _ { j } } \right)
+$$
+
+We minimize the negative log-probability and do continuous approximations as before, resulting in the final form of the BPR-max loss function (16). The regularization term is a simple, softmax weighted $\ell _ { 2 }$ regularization over the scores. $\lambda$ is the regularization hyperparameter of the loss.
+
+$$
+L _ { \mathrm { b p r - m a x } } = - \log \sum _ { j = 1 } ^ { N _ { S } } s _ { j } \sigma ( r _ { i } - r _ { j } ) + \lambda \sum _ { j = 1 } ^ { N _ { S } } s _ { j } r _ { j } ^ { 2 }
+$$
+
+# 4 EXPERIMENTS
+
+Experimental setup: We evaluated the proposed improvements – fixed cross-entropy loss, rankingmax loss functions & adding additional samples – on four dataset. RSC15 is based on the dataset of RecSys Challange $2 0 1 5 ^ { 9 }$ , which contains click and buy events from an online webshop. We only kept the click data. VIDEO and VIDXL are proprietary datasets containing watch events from an online video service. Finally, CLASS is a proprietary dataset containing item page view events from an online classified site. Datasets were subjugated to minor preprocessing then split into train and test sets so that a whole session either belongs to the train or to the test set. The split is based on the time of the first event of the sessions. The datsets and the split are exactly the same for RSC15 as in Hidasi et al. (2016a); and for VIDXL and CLASS as in Hidasi et al. (2016b). VIDEO is of the same source as in Hidasi et al. (2016a), but a slightly different subset. Table 1 overviews the main properties of the datasets.
+
+Table 1: Properties of the datasets.   
+
+<table><tr><td>Data</td><td colspan="2">Train set</td><td colspan="2">Test set</td><td>Items</td></tr><tr><td></td><td>Sessions</td><td>Events</td><td>Sessions</td><td>Events</td><td></td></tr><tr><td>RSC15</td><td>7,966,257</td><td>31,637,239</td><td>15,324</td><td>71,222</td><td>37,483</td></tr><tr><td>VIDEO</td><td>2,144,930</td><td>10,214,429</td><td>29,804</td><td>153,157</td><td>262.050</td></tr><tr><td>VIDXL</td><td>17,419,964</td><td>69,312,698</td><td>216,725</td><td>921,202</td><td>712,824</td></tr><tr><td>CLASS</td><td>1,173.094</td><td>9,011,321</td><td>35,741</td><td>254,857</td><td>339.055</td></tr></table>
+
+Evaluation is done under the next item prediction scenario, that is we iterate over test sessions and events therein. For each event, the algorithm guesses the item of the next event of that session. Since the size of the VIDXL test set is large, we compare the target item’s score to that of the $5 0 , 0 0 0 \mathrm { m o s t }$ popular items during testing, similarly to Hidasi et al. (2016b). While this evaluation for VIDXL overestimates the performance, the comparison of algorithms remain fair Bellogin et al. (2011). As recommender systems can only recommend a few items at once, the actual item a user might pick should be amongst the first few items of the list. Therefore, our primary evaluation metric is recall $\textcircled{ a} 2 0$ that is the proportion of cases having the desired item amongst the top-20 items in all test cases. Recall does not consider the actual rank of the item as long as it is amongst the top-N. This models certain practical scenarios well where there is no highlighting of recommendations and the absolute order does not matter. Recall also usually correlates well with important online KPIs, such as click-through rate (CTR)Liu et al. (2012); Hidasi & Tikk (2012). The second metric used in the experiments is MRR $@ 2 0$ (Mean Reciprocal Rank). That is the average of reciprocal ranks of the desired items. The reciprocal rank is set to zero if the rank is above 20. MRR takes into account the rank of the item, which is important in cases where the order of recommendations matter (e.g. the lower ranked items are only visible after scrolling).
+
+The natural baseline we use is the original GRU4Rec algorithm, upon which we aim to improve. We consider the results with the originally proposed TOP1 loss and tanh activation function on the output to be the baseline. The hidden layer has 100 units. We also indicate the performance of item-kNN, a natural baseline for next item prediction. Results for RSC15, VIDXL and CLASS are taken directly from corresponding papers Hidasi et al. (2016a;b) and measured with the optimal hyperparameters in Hidasi et al. (2016a) for VIDEO. We do separate hyperparameter optimization on a separate validation set for the proposed improvements.
+
+The methods are implemented under the Theano framework Al-Rfou et al. (2016) in python. Experiments were run on various GPUs, training times were measured on an unloaded Titan X (Maxwell) GPU. Code is available publicly on GitHub10 for reproducibility.
+
+# 4.1 USING ADDITIONAL SAMPLES
+
+The first set of experiments examines the effect of additional negative samples on recommendation accuracy. Experiments were performed on the CLASS and the VIDEO datasets. Since results are quite similar we excluded the VIDEO results to save some space. Figure 3a depicts the performance of the network with TOP1, cross-entropy, TOP1-max and BPR-max losses. Recommendation accuracy was measured with different number of additional samples, as well as in the case when all scores are computed and there is no sampling. As we discussed earlier, this latter scenario is a more theoretical one, because it is not scalable. As theory suggests (see Section 3), the TOP1 loss does not cope well with lots of samples. There is a slight increase in performance with a few extra samples, as the chance of having relevant samples increases; but performance quickly degrades as sample size grow, thus lots of irrelevant samples are included. On the other hand, all three of the other losses react well to adding more samples. The point of diminishing return is around a few thousand of extra samples for cross-entropy. TOP1-max starts to slightly lose accuracy after that. BPR-max improves with more samples all the way, but slightly loses accuracy when all items are used.
+
+![](images/f1f35c240d5f7b29320f1efa0f732beedc675609e96f1d477d3b27928aece7c6.jpg)  
+Figure 3: Results on the CLASS dataset. ”ALL” means no sampling of items.
+
+Adding extra samples increase computational cost, yet due to easy parallelization on modern GPUs most of this cost is alleviated. Figure 3b shows the training times at different sample sizes. Please note the logarithmic scale. The actual training time depends on not just the dataset, but model parameters (especially mini-batch size) and how certain operators used for computing the loss are supported by the framework. The trend, however, is similar to for all losses. For example, the full training of the network is around 10 minutes (with the settings for cross-entropy or TOP1-max), which does not increase with even 512 extra samples. At the point of diminishing returns, i.e. at 2048 extra samples, training time is around 15 minutes, which is also totally acceptable. After that, training times grow quickly, due to exceeding the parallelization capabilities of the GPU we used. The trend is similar on the VIDEO dataset, with training times starting around 50 minutes, starting to increase at 2048 extra samples (to 80 minutes) and quickly above thereafter. This means that the proposed method can be used with zero too little additional cost in practice, unlike data augmentation methods. It is also clear that GRU4Rec can work just as well with a few thousands of negative examples as with the whole itemset, thus it can be kept scalable.
+
+In the next experiment we perform a parameter sensitivity analysis of the $\alpha$ parameter that controls the sampling. Figure 4 depicts the performance over different $\alpha$ values for the cross-entropy, TOP1- max and BPR-max losses. Cross-entropy favors higher $\alpha$ values with low sample sizes and low $\alpha$ values for large samples. This is inline with our discussion in Section 2: popular samples are useful when the sample size is very limited and at the beginning of the training, but might be exhausted quickly, thus switching to a more balanced sampling can be beneficial if we have the means to (e.g. large enough sample size). Also, the uniform sampling in this case is supplemented by the few popularity based samples of the mini-batch sampling. The ranking-max losses, on the other hand, seem to prefer the middle road with a slight preference towards higher values, while the extremes perform the worst. We assume that this is mostly due to (a) being based on pairwise losses, where popular samples are usually desired; (b) and the score regularization: with popularity based sampling the scores of the most popular items would be decreased beyond what is desirable.
+
+![](images/346620a270a18c8f1e066a9ecc336da9567ec1c2673711f73bc43cc95f5c763c.jpg)  
+Figure 4: The effect of the alpha parameter on recommendation accuracy at different sample sizes on the CLASS dataset. Left: cross-entropy loss; Middle: TOP1-max loss; Right: BPR-max loss.
+
+Table 2: Recommendation accuracy with additional samples and different loss functions compared to item-kNN and the original GRU4Rec. Improvements over item-kNN and the original GRU4Rec (with TOP1 loss) results are shown in parentheses. Best results are typeset bold.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Item kNN</td><td colspan="2">GRU4Rec original</td><td colspan="4">GRU4Rec with additional samples</td></tr><tr><td></td><td>XE</td><td>TOP1</td><td>XE</td><td>TOP1-max</td><td>BPR-max</td></tr><tr><td colspan="8">Recall@20</td></tr><tr><td>RSC15</td><td>0.5065</td><td>0.5853</td><td>0.5781</td><td>0.6117 (+20.77%,+4.51%)</td><td>0.7112 (+40.41%,+21.51%)</td><td>0.7086 (+39.91%,+21.07%)</td><td>0.7190 (+41.95%,+22.84%)</td></tr><tr><td>VIDEO VIDXL</td><td>0.5201</td><td>0.5051</td><td>0.5060</td><td>0.5325 (+2.40%,+5.43%)</td><td>0.6222 (+19.63%,+23.18%)</td><td>0.6421 (+23.46%,+27.12%)</td><td>0.6524 (+25.44%,+29.16%)</td></tr><tr><td>CLASS</td><td>0.6263 0.2201</td><td>0.6831 0.2478</td><td>0.7046 0.2545</td><td>0.6723 (+7.35%,-1.58%) 0.2342 (+6.41%,-5.50%)</td><td>0.7972 (+27.29%,+16.70%) 0.3099 (+40.83%,+25.07%)</td><td>0.7935 (+26.70%,+16.16%) 0.3252 (+47.75%,+31.22%)</td><td>0.8020 (+28.05%,+17.41%) 0.3342 (+51.84%,+34.87%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan="8">MRR@20</td></tr><tr><td>RSC15</td><td>0.2048</td><td>0.2305</td><td>0.2375</td><td>0.2367 (+15.61%,+2.69%)</td><td>0.3059 (+49.41%,+32.71%)</td><td>0.3045 (+48.70%,+32.08%)</td><td>0.3119 (+52.29%,+35.31%)</td></tr><tr><td>VIDEO VIDXL</td><td>0.2257</td><td>0.2359</td><td>0.2609</td><td>0.2295 (+1.69%,-2.73%)</td><td>0.2970 (+31.63%,+25.92%)</td><td>0.2950 (+30.72%,+25.05%)</td><td>0.3019 (+33.76%, +27.98%)</td></tr><tr><td>CLASS</td><td>0.3740</td><td>0.3847</td><td>0.4343</td><td>0.3608 (-3.53%,-6.21%)</td><td>0.5023 (+34.31%, +30.59%)</td><td>0.4939 (+32.05%,+28.39%)</td><td>0.5013 (+34.01%,+30.30%)</td></tr><tr><td></td><td>0.0799</td><td>0.0949</td><td>0.0995</td><td>0.0870 (+8.83%,-8.36%)</td><td>0.1176 (+47.14%,+23.90%)</td><td>0.1198 (+49.93%,+26.25%)</td><td>0.1207 (+51.06%,+27.19%)</td></tr></table>
+
+# 4.2 LOSS-FUNCTIONS
+
+We measure the performance gain of the proposed improvements over the baselines. The big accuracy improvement comes from the combination of additional samples and the loss functions (fixed cross-entropy, TOP1-max and BPR-max). Table 2 showcases our most important results. Besides the original version of GRU4Rec and the item-kNN, we included results with cross-entropy (XE) loss without additional sampling to confirm that the fixed cross-entropy loss still performs just slightly better than TOP1. The increase with sampling and the proper loss function is stunning as the best results exceed the accuracy of the original GRU4Rec by $1 5 - 3 5 \%$ and that of item-kNN by up to $5 2 \%$ . BPR-max even performs slightly better $( + 1 - 7 \% )$ than cross-entropy on 3 of 4 datasets and achieves similar results on the remaining one dataset.
+
+On RSC15, Tan et al. (2016) reported $\sim 0 . 6 8 5$ and $\sim 0 . 2 9$ in recall $@ 2 0$ and MRR $\textcircled{ a} 2 0$ respectively11 using data augmentation. Unlike our solutions, data augmentation greatly increases training times. Data augmentation and our improvements are not mutually exclusive, thus it is possible that combining the two methods, even better results can be achieved. A very recent paper Chatzis et al. (2017) proposes the Bayesian version of GRU4Rec and reports $\sim 0 . 6 1$ and $\sim 0 . 2 5$ in recall $\textcircled{ a} 2 0$ and MRR $@ 2 0$ when using 100 units12. Therefore our GRU4Rec version is the current best performer so far.
+
+Table 3: Results with unified embeddings   
+
+<table><tr><td>Dataset</td><td>Recall@20</td><td>MRR@20</td></tr><tr><td>RSC15</td><td>0.7220</td><td>0.3070</td></tr><tr><td>VIDEO</td><td>0.6612</td><td>0.2923</td></tr><tr><td>VIDXL</td><td>0.8045</td><td>0.4915</td></tr><tr><td>CLASS</td><td>0.3844</td><td>0.1471</td></tr></table>
+
+# 4.3 UNIFIED ITEM REPRESENTATIONS
+
+Previous experiments did not find any benefits of using an embedding layer before the GRU layers. The role of the embedding layer is to translate item IDs into the latent representation space. In the recommender systems terminology, item embeddings correspond to “item feature vectors”. The network has another “item feature matrix” in the form of the output weight matrix. By unifying the representations, i.e. sharing the weight matrix between the embedding layer and the output layer, we learn better item representations quicker. Preliminary experiments (Table 3) show additional improvements in recall $\textcircled{ a} 2 0$ and slight decrease in $\mathbf { M R R } @ 2 0$ for most of the datasets, however, for the CLASS dataset both recall and MRR are increased significantly when unified embeddings are used $( + 1 5 . 0 2 \%$ and $+ 2 1 . 8 7 \%$ in recall and MRR respectively, compared to the model trained without embeddings).
+
+# 5 CONCLUSION
+
+We introduced a new class of loss function that together with an improved sampling strategy have provided impressive top- $\mathbf { \nabla } \cdot \mathbf { k }$ gains for RNNs for session-based recommendations. We believe that these new losses could be more generally applicable and along with the corresponding sampling strategies also provide top- $\mathbf { \nabla } \cdot \mathbf { k }$ gains for different recommendations settings and algorithms such as e.g. matrix factorization or autoencoders. It is also conceivable that these techniques could also provide similar benefits in the area of Natural Language Processing a domain that shares significant similarities to the recommendation domain in terms of machine learning (e.g. ranking, retrieval) and data structure (e.g. sparse large input and output space).
+
+# REFERENCES
+
+Rami Al-Rfou, Guillaume Alain, Amjad Almahairi, Christof Angermueller, Dzmitry Bahdanau, Nicolas Ballas, Fred´ eric Bastien, Justin Bayer, Anatoly Belikov, Alexander Belopolsky, et al. ´ Theano: A python framework for fast computation of mathematical expressions. arXiv preprint arXiv:1605.02688, 2016.   
+Alejandro Bellogin, Pablo Castells, and Ivan Cantador. Precision-oriented evaluation of recommender systems: An algorithmic comparison. In RecSys’11: 5th ACM Conf. on Recommender Systems, pp. 333–336, 2011. ISBN 978-1-4503-0683-6. doi: 10.1145/2043932.2043996. URL http://doi.acm.org/10.1145/2043932.2043996.   
+Chris J.C. Burges. From ranknet to lambdarank to lambdamart: An overview. Technical report, June 2010. URL https://www.microsoft.com/en-us/research/publication/ from-ranknet-to-lambdarank-to-lambdamart-an-overview/.   
+Sotirios Chatzis, Panayiotis Christodoulou, and Andreas S Andreou. Recurrent latent variable networks for session-based recommendation. arXiv preprint arXiv:1706.04026, 2017.   
+Kyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder–decoder approaches. In SSST-8: 8th Workshop on Syntax, Semantics and Structure in Statistical Translation, pp. 103–111, 2014.   
+Robin Devooght and Hugues Bersini. Collaborative filtering with recurrent neural networks. arXiv preprint arXiv:1608.07400, 2016.   
+B. Hidasi and D. Tikk. Fast ALS-based tensor factorization for context-aware recommendation from implicit feedback. In ECML-PKDD’12, Part II, number 7524 in LNCS, pp. 67–82. Springer, 2012.
+
+Balazs Hidasi, Alexandros Karatzoglou, Linas Baltrunas, and Domonkos Tikk. Session-based rec- ´ ommendations with recurrent neural networks. International Conference on Learning Representations, 2016a. URL http://arxiv.org/abs/1511.06939.
+
+Balazs Hidasi, Massimo Quadrana, Alexandros Karatzoglou, and Domonkos Tikk. Parallel recurrent ´ neural network architectures for feature-rich session-based recommendations. In Proceedings of the 10th ACM Conference on Recommender Systems, RecSys ’16, pp. 241–248, New York, NY, USA, 2016b. ACM. ISBN 978-1-4503-4035-9. doi: 10.1145/2959100.2959167. URL http: //doi.acm.org/10.1145/2959100.2959167.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Shihao Ji, SVN Vishwanathan, Nadathur Satish, Michael J Anderson, and Pradeep Dubey. Blackout: Speeding up recurrent neural network language models with very large vocabularies. ICLR, 2016.
+
+Yehuda Koren and Joe Sill. Ordrec: An ordinal model for predicting personalized item rating distributions. In Proceedings of the Fifth ACM Conference on Recommender Systems, RecSys ’11, pp. 117–124, New York, NY, USA, 2011. ACM.
+
+G. Linden, B. Smith, and J. York. Amazon.com recommendations: Item-to-item collaborative filtering. Internet Computing, IEEE, 7(1):76–80, 2003.
+
+Qiwen Liu, Tianjian Chen, Jing Cai, and Dianhai Yu. Enlister: Baidu’s recommender system for the biggest Chinese Q&A website. In RecSys-12: Proc. of the 6th ACM Conf. on Recommender Systems, pp. 285–288, 2012.
+
+S. Rendle, C. Freudenthaler, Z. Gantner, and L. Schmidt-Thieme. BPR: Bayesian personalized ranking from implicit feedback. In UAI’09: $2 5 ^ { t h }$ Conf. on Uncertainty in Artificial Intelligence, pp. 452–461, 2009a. ISBN 978-0-9749039-5-8.
+
+Steffen Rendle, Christoph Freudenthaler, Zeno Gantner, and Lars Schmidt-Thieme. Bpr: Bayesian personalized ranking from implicit feedback. In Proceedings of the Twenty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI ’09, pp. 452–461, 2009b.
+
+Badrul Sarwar, George Karypis, Joseph Konstan, and John Riedl. Item-based collaborative filtering recommendation algorithms. In WWW:01: 10th Int. Conf. on World Wide Web, pp. 285–295, 2001.
+
+Yue Shi, Alexandros Karatzoglou, Linas Baltrunas, Martha Larson, Nuria Oliver, and Alan Hanjalic. Climf: Learning to maximize reciprocal rank with collaborative less-is-more filtering. In Proceedings of the Sixth ACM Conference on Recommender Systems, RecSys ’12, pp. 139–146, 2012. ISBN 978-1-4503-1270-7. doi: 10.1145/2365952.2365981. URL http://doi.acm. org/10.1145/2365952.2365981.
+
+Yong Kiam Tan, Xinxing Xu, and Yong Liu. Improved recurrent neural networks for session-based recommendations. In Proceedings of the 1st Workshop on Deep Learning for Recommender Systems, DLRS 2016, pp. 17–22, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4795- 2. doi: 10.1145/2988450.2988452. URL http://doi.acm.org/10.1145/2988450. 2988452.
+
+Markus Weimer, Alexandros Karatzoglou, Quoc Viet Le, and Alex Smola. Cofirank maximum margin matrix factorization for collaborative ranking. In Proceedings of the 20th International Conference on Neural Information Processing Systems, NIPS’07, pp. 1593–1600, 2007.
+
+Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recommender networks. In Proceedings of the Tenth ACM International Conference on Web Search and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM.

parse/train/ryCM8zWRb/ryCM8zWRb_content_list.json

@@ -0,0 +1,1281 @@
+[
+    {
+        "type": "text",
+        "text": "RECURRENT NEURAL NETWORKS WITH TOP-K GAINS FOR SESSION-BASED RECOMMENDATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "RNNs have been shown to be excellent models for sequential data and in particular for session-based user behavior. The use of RNNs provides impressive performance benefits over classical methods in session-based recommendations. In this work we introduce a novel ranking loss function tailored for RNNs in recommendation settings. The better performance of such loss over alternatives, along with further tricks and improvements described in this work, allow to achieve an overall improvement of up to $3 5 \\%$ in terms of MRR and Recall $\\textcircled{ a} 2 0$ over previous session-based RNN solutions and up to $51 \\%$ over classical collaborative filtering approaches. Unlike data augmentation-based improvements, our method does not increase training times significantly. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            336,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Session-based recommendation is a very common recommendation problem that is encountered in many domains such as e-commerce, classified sites, music and video recommendation. In the session-based setting, past user history logs are typically not available (either because the user is new or not logged-in or not tracked) and recommender systems have to rely only on the actions of the user in the current sessions to provide accurate recommendations. Until recently many of these recommendations tasks were tackled mainly using relatively simple methods such as item-based collaborative filtering (Sarwar et al., 2001) or content-based methods. Recurrent Neural Networks (RNNs) have emerged from the deep learning literature as powerful methods for modeling sequential data. These models have been successfully applied in speech recognition, translation, time series forecasting and signal processing. In recommender systems RNNs have been recently applied to the session-based recommendation setting with impressive results (Hidasi et al., 2016a). ",
+        "bbox": [
+            174,
+            479,
+            825,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The advantage of RNNs over traditional similarity-based methods for recommendation is that they can effectively model the whole session of user interactions (clicks, views, etc.). By modeling the whole session RNNs can in effect learn the ‘theme’ of the session and thus provide recommendations with increased accuracy (between $2 0 \\% { - } 3 0 \\%$ ) over traditional methods. ",
+        "bbox": [
+            176,
+            638,
+            823,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "RNNs in session-based recommendation have been adapted to the task of recommendation. One of the main objectives in recommendation is to rank items by user preference; i.e. the exact ranking or scoring of items in the tail of the item list (items that the user will not like) is not that important, but it is very important to rank correctly the items that the user will like at the top of the list (first 5, 10 or 20 positions). To achieve this with machine learning one has to typically utilize learning to rank techniques(see e.g. (Burges, 2010)) and in particular ranking objectives and loss functions. The current session-based RNN approaches use ranking loss functions and, in particular, pairwise ranking loss functions. As in most deep learning approaches the choice of a good ranking loss can have a very significant influence on performance. Since deep learning methods need to propagate gradients over several layers and in the case of RNNs ’back in time’ over previous steps, to optimize the model parameters, the quality of these gradients originating from the loss function influences the quality of the optimization and the model parameters. Moreover the nature of the recommendation task, which typically entails large output spaces (due to large number of items), poses unique challenges that have to be taken into account as well when designing a proper ranking loss function. We will see that the way this large output space issue is tackled is very crucial in achieving good performance. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we analyze ranking loss functions used in RNNs for session-based recommendations, this analysis leads to a new set of ranking loss functions that increase the performance of the RNN up to $30 \\%$ over previous commonly used losses without incurring in significant computational overheads. We essentially devise a new class of loss functions that combines learnings from the deep learning and the learning to rank literature. Experimental results on several datasets coming from industry validate these impressive improvements, in terms of Mean Reciprocal Rank (MRR) and Recall $\\textcircled{ a} 2 0$ . With these improvements the difference between RNNs and conventional memory-based collaborative filtering jumps to $51 \\%$ in terms of MRR and Recall $\\textcircled{ a} 2 0$ demonstrating the potential that deep learning methods bring to the area of Recommender Systems. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            247,
+            330,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One of the main approaches that is employed in session-based recommendation and a natural solution to the problem of a missing user profile is the item-to-item recommendation approach (Sarwar et al., 2001; Linden et al., 2003). In this setting, an item-to-item similarity matrix is precomputed from the available session data, that is items that are often clicked together in sessions are deemed to be similar. This similarity matrix is then simply used during the session to recommend the most similar items to the one the user has currently clicked. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            357
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Long Short-Term Memory (LSTM) Hochreiter & Schmidhuber (1997) networks are a type of RNNs that have been shown to solve the optimization issues the plague vanilla-type RNNs. LSTM’s include additional gates that regulate when and how much of the input to take into account and when to reset the hidden state. A slightly simplified version of LSTM – that still maintains all their properties – are Gated Recurrent Units (GRUs) Cho et al. (2014), which we use in this work. Recurrent Neural Networks have been used with success in the area of session-based recommendations; (Hidasi et al., 2016a) proposed a Recurrent Neural Network with a pairwise ranking loss for this task, (Tan et al., 2016) proposed data augmentation techniques to improve the performance of the RNN for session-based recommendations; these techniques have though the side effect of increasing training times as a single session is split into several sub-sessions for training. Session-based RNNs have been augmented (Hidasi et al., 2016b) with feature information, such as text and images from the clicked/consumed items, showing improved performance over the plain models. RNNs have also been used in more standard user-item collaborative filtering settings where the aim is to model the evolution of the user and items factors (Wu et al., 2017),(Devooght & Bersini, 2016) where the results are less striking, with the proposed methods barely outperforming standard matrix factorization methods. This is to be expected as there is no strong evidence on major user taste evolution in a single domain in the timeframes of the available datasets and sequential modeling of items that are not ’consumed’ in sessions such as movies might not bring major benefits. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another area touched upon in this work are loss functions tailored to recommender systems requirements. This typically means ranking loss functions. In this area there has been work particularly in the context of matrix factorization techniques. One of the first learning to rank techniques for collaborative filtering was introduced in (Weimer et al., 2007). Essentially a listwise loss function was introduced along with an alternating bundle method for optimization of the factors. Further ranking loss function for collaborative filtering were introduced in (Shi et al., 2012) (Rendle et al., 2009b) and (Koren & Sill, 2011). Note that the fact that these loss functions work well in matrix factorization does not guarantee in any way that they are an optimal choice for RNNs as backpropagation requirements are stronger than those posed by simple SGD. We will in fact see that BPR, a popular choice of loss function, needs to be significantly modified to extract optimal results in the case of RNNs for session-based recommendations. Another work related to sampling large output spaces in deep networks for efficient loss computations for language models is the ’blackout’ method (Ji et al., 2016), where essentially a sampling procedure similar to the one used in (Hidasi et al., 2016a) is applied in order to efficiently compute the categorical cross-entropy loss. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 SAMPLING THE OUTPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            405,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the remainder of the paper we will refer to the RNN algorithm implemented in (Hidasi et al., 2016a) as GRU4Rec, the name of the implementation published by the authors on github 1. In this section we revisit how GRU4Rec samples negative feedback on the output and discuss its importance. We extend this sampling with an option for additional samples and argue that this is crucial for the increased recommendation accuracy we achieve (up to $51 \\%$ improvement). ",
+        "bbox": [
+            176,
+            869,
+            823,
+            897
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In each training step, GRU4Rec takes the item of the current event in the session – represented by a one-hot vector – as an input. The output of the network is a set of scores over the items, corresponding to their likelihood of being the next item in the session. The training iterates through all events in the sequence. The complexity of the training with backpropagation through time is $O ( N _ { E } ( H ^ { 2 } + H { N _ { O } } ) )$ where $N _ { E }$ is the number of training events, $H$ is the number of hidden units and $N _ { O }$ is the number of outputs, for which scores are computed. Computing scores for all items is very impractical, since it makes the network unscalable2. Therefore GRU4Rec uses a sampling mechanism and during training computes the scores for a subset of the items only. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instead of making a forward and backward pass with one training example only and then moving to the next, the network is fed with a bundle of examples and is trained on the mean gradient. This common practice is called mini-batch training and has several benefits, e.g. utilizing the parallelization capabilities of current hardware better, thus training faster, and producing more stable gradients than stochastic gradient training and thus converging faster. GRU4Rec introduced mini-batch based sampling Hidasi et al. (2016a). For each example in the mini-batch, the other examples of the same mini-batch serve as negative examples (see Figure 1).3 This method is practical from an implementation point of view and can be also implemented efficiently for GPUs. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b301f02dce3fe8cdc0e08469fa25de3bdd5edc2f9a32fb1f015357edca0546ec.jpg",
+        "image_caption": [
+            "Figure 1: Mini-batch sampling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            396,
+            725,
+            510
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The network can be trained with one of three different listwise ranking loss functions (see Section 3). All loss functions require a score for the target item (i.e. for the item which was the actual next item) and score(s) for at least one negative sample (i.e. item other than the target). One property of ranking losses is that learning happens only if the score of the target item does not exceed that of the negative samples by a large margin, otherwise the items are already in the right order, so there is nothing to be learned. Therefore, when utilizing a sampling procedure, it is crucial that high scoring items make it among the negative samples. Whether an item has a high score, depends on the context (item sequence) the scores are actually computed for. Popular items generally score high in many situations, making popularity-based sampling a good sampling strategy. Mini-batch sampling is basically a form of popularity-based sampling, since the training iterates through all events, thus the probability of an item acting as a negative sample is proportional to its support. The problem with popularity-based sampling is that learning can slow down after the algorithm learns to (generally) rank target items above popular ones, and thus can still be inaccurate with ranking long tail high scoring items. On the other hand, uniform sampling slows down learning, due to the high number of low scoring negative samples, but might produce an overall more accurate model if trained indefinitely. In our experience, popularity-based sampling generally produces better results. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Tying sampling to the mini-batches has several practical benefits, but is too restrictive for three reasons. (1) Mini-batch sizes are generally small, ranging from few tens to few hundreds. If the number of items is large, the small sample size further hinders the chance of including all of the high scoring negative examples. (2) Mini-batch size has a direct effect on the training. E.g. we found that training with smaller mini-batch sizes (30-100) produces more accurate models, but training with larger ones is faster on the GPU due to parallelization. (3) The sampling method is inherently popularity-based, which generally is a good strategy, but might not be optimal for all datasets. ",
+        "bbox": [
+            174,
+            779,
+            823,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore we extend the sampling of GRU4Rec with additional samples. We sample $N _ { A }$ items which are shared by the examples of the mini-batch, i.e. the same samples are used for each exam$\\mathrm { p l e } ^ { 4 }$ . These additional samples are used along with the $N _ { B } - 1$ samples coming from the mini-batch (popularity) sampling. Additional samples can be sampled in any way, we chose to sample proportional to $\\mathrm { s u p p } _ { i } ^ { \\alpha }$ , where ${ \\mathrm { s u p p } } _ { i }$ is the support of the item and $\\alpha$ is the parameter of the sampling. $\\alpha = 0$ and $\\alpha = 1$ gives uniform and popularity-based sampling respectively. ",
+        "bbox": [
+            174,
+            152,
+            823,
+            237
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adding more samples naturally increases the complexity, since $N _ { O }$ increases from $N _ { B }$ to $N _ { A } + N _ { B }$ . However, the computations are easily parallelizable, thus there is no actual increase in the training time on modern GPUs up to a certain sample size (see Section 4.1). The efficient implementation of this sampling however is not trivial. Sampling according to a distribution on GPUs is slow, thus it should be handled by the CPU. The sampled item IDs can be given to the GPU along with the item IDs of the mini-batch. Sampling the distribution takes some time every time a new minibatch is formed, thus GPU execution is frequently interrupted, making GPU utilization low and thus training slow. On the top of that, sampling a few items at once is less efficient than sampling lots of them, even on CPU. Therefore we implemented a cache that pre-samples and stores lots of negative samples. Training uses up these samples and the cache is recomputed once it is empty. We found that pre-sampling 10-100 million item IDs significantly improves training speed when compared to using no cache at all. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 LOSS FUNCTION DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            433,
+            410,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section we examine the loss functions implemented in GRU4Rec and identify their weaknesses. We propose two ways to stabilize the numerical instability of the cross-entropy loss, we show how learning with the TOP1 and BPR pairwise losses degrades as we add more samples to the output, and propose a family of loss functions based on pairwise losses that alleviates this problem. We note that, while our aim is to improve GRU4Rec, the loss functions proposed in this section can be also used with other models, such as matrix factorization. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 CATEGORICAL CROSS-ENTROPY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            434,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Categorical cross-entropy measures the distance of a proposed (discrete) probability distribution $q$ from the target distribution $p$ as defined by (1). ",
+        "bbox": [
+            176,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff36cf61b79aa40ae95f89ea022f09874b96622891cf062948dd895d66a358de.jpg",
+        "text": "$$\nH ( p , q ) = - \\sum _ { j = 1 } ^ { N } p _ { j } \\log q _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            643,
+            584,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This loss is often used in machine learning and deep learning in particular for multi-class classification problems. Next item recommendation can be interpreted as classification, where the class labels are the items in the system and item sequences need to be assigned with the label of the item that follows. In a single-label scenario – such as next item recommendation – the target distribution is a one-hot vector over the set of items, with the coordinate corresponding to the target item set to 1. The proposed distribution consists of the scores assigned to the items by the algorithm. The output scores need to be transformed to form a distribution. It is common practice to use the softmax transformation (2), which is a continuous approximation of the max operation. This naturally aligns with the sentiment that the label with the highest score is assigned to the sequence. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98b7bb5973217ffc4410c815fa6c7cd7605e90cab3da958939ee35f4ce20b886.jpg",
+        "text": "$$\ns _ { i } = \\frac { e ^ { r _ { i } } } { \\sum _ { j = 1 } ^ { N } e ^ { r _ { j } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            845,
+            552,
+            885
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Cross-entropy in itself is a pointwise loss, (that is it can be computed per individual item) as it is the sum of independent losses defined over the coordinates. Combining it with softmax introduces listwise properties into the loss, since the loss now cannot be separated over coordinates (or items). Putting them together we get the following loss function over the scores (assuming that the target item is indexed by $i$ ): ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b4cd821058ee366d0358bd3dd1f2638089cc78d4d0bbe0d2518435d34569296.jpg",
+        "text": "$$\nL _ { \\mathrm { x e } } = - \\log s _ { i } = - \\log \\frac { e ^ { r _ { i } } } { \\sum _ { j = 1 } ^ { N } e ^ { r _ { j } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            190,
+            614,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fixing the instability: One of the losses available in GRU4Rec was cross-entropy with softmax scores. Hidasi et al. (2016a) reported slightly better results than with other losses, but deemed the loss to be unstable for a large fraction of the hyperparameter space and thus advised against its use. This instability comes from the limited numerical precision. Assuming that there is a $k$ for which $r _ { k } \\gg r _ { i }$ , $s _ { i }$ becomes very small and rounded to 0, because of the limited precision. The loss then computes $\\log 0$ , which is undefined. Two ways to circumvent this problem are as follow: (a) compute $- \\log ( s _ { i } + \\epsilon )$ , where $\\epsilon$ is a very small value (we use $1 0 ^ { - 2 4 }$ ); (b) compute $- \\log s _ { i }$ directly as $\\textstyle - r _ { i } + \\log \\sum _ { j = 1 } ^ { N } e ^ { r _ { j } }$ . The former introduces some noise, while the latter does not allow the separated use of the transformation and the loss, but both methods stabilize the loss. We did not observe any differences in the results of the two variants. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 RANKING LOSSES: TOP1 & BPR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            401,
+            446,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GRU4Rec offers two loss functions based on pairwise losses. Pairwise losses compare the score of the target to a negative example (i.e. any item other than the target). The loss is high if the target’s score is higher than that of the negative example. GRU4Rec computes scores for multiple negative samples per each target, and thus the loss function is composed as the average of the individual pairwise losses. This results in a listwise loss function, which is composed of pairwise losses. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One of the loss functions is coined TOP1 (4). It is a heuristically put together loss consisting of two parts. The first part aims to push the target score above the score of the samples, while the second part lowers the score of negative samples towards zero. The latter acts as a regularizer, but instead of constraining the model weights directly, it penalizes high scores on the negative examples. Since all items act as a negative score in one training example or another, it generally pushes the scores down. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4661621d3eccce68503cb6120657f488df7bdef486e7b476e4c51034020a6509.jpg",
+        "text": "$$\nL _ { \\mathrm { t o p 1 } } = \\frac { 1 } { N _ { S } } \\sum _ { j = 1 } ^ { N _ { S } } \\sigma ( r _ { j } - r _ { i } ) + \\sigma ( r _ { j } ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            606,
+            622,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$j$ runs over the $( N _ { S } )$ sampled negative (’non-relevant’) items, relevant items are index by $i$ . The other loss function (5) is based on the popular Bayesian Personalized Ranking (BPR) Rendle et al. (2009a) loss. Here the negative log-probability of the target score exceeding the sample scores is minimized (i.e. the probability of target scores being above sample scores is maximized). The non-continuous $P ( r _ { i } > r _ { j } )$ is approximated by $\\sigma ( r _ { i } - r _ { j } )$ . ",
+        "bbox": [
+            173,
+            654,
+            825,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3677113e43315a16613b96cb89dcc661bdd6256e5ee17c5638536bec3a22f1c.jpg",
+        "text": "$$\nL _ { \\mathrm { b p r } } = - \\frac { 1 } { N _ { S } } \\sum _ { j = 1 } ^ { N _ { S } } \\log \\sigma ( r _ { i } - r _ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            742,
+            607,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 VANISHING GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            395,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Taking the average of individual pairwise losses has an undesired side effect. Examining the gradients for the TOP1 and BPR losses w.r.t. the target score $r _ { i }$ , ((6) and (7) respectively) reveals that under certain circumstances gradients vanish and thus learning stops. With pairwise losses, one generally wants to have negative samples with high scores, as those samples produce high gradients. Or intuitively, if the score of the negative sample is already well below that of the target, there is nothing to learn from that negative sample anymore. For this discussion we will denote samples where $r _ { j } \\ \\ll \\ r _ { i }$ irrelevant. For an irrelevant sample $\\sigma ( r _ { j } \\mathrm { ~ - ~ } r _ { i } )$ in ((6) and $1 - \\sigma ( r _ { i } - r _ { j } )$ (7) ",
+        "bbox": [
+            173,
+            825,
+            825,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "will be close to zero. Therefore, any irrelevant sample adds basically nothing to the total gradient. Meanwhile the gradient is always discounted by the total number of negative samples. By increasing the number of samples, the number of irrelevant samples increases faster than that of including relevant samples, since the majority of items is irrelevant as a negative sample. This is especially true for non-popularity-based sampling and high sample numbers. Therefore these losses start to vanish as the number of samples increase, which is counterintuitive and hurts the full potential of the algorithm.56 ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e195f202edd3ac94e43da0a74ae6a3aba429928668c384b78a9b0c1a560cd93c.jpg",
+        "text": "$$\n\\frac { \\partial L _ { \\mathrm { t o p 1 } } } { \\partial r _ { i } } = - \\frac { 1 } { N _ { S } } \\sum _ { j = 1 } ^ { N _ { S } } \\sigma ( r _ { j } - r _ { i } ) \\left( 1 - \\sigma ( r _ { j } - r _ { i } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            220,
+            661,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ff692e0c31fa1c2bd012301c1be74b7ccdff9cda5ff2bebe1c8a9215f6e3a3c.jpg",
+        "text": "$$\n\\frac { \\partial L _ { \\mathrm { b p r } } } { \\partial r _ { i } } = - \\frac { 1 } { N _ { S } } \\sum _ { j = 1 } ^ { N _ { S } } \\left( 1 - \\sigma ( r _ { i } - r _ { j } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            281,
+            622,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note, that TOP1 is sensitive to relevant examples where $r _ { j } \\gg r _ { i }$ , which is an oversight in the design of the loss. While this is unlikely to happen, it cannot be outruled. For example, when comparing a niche target to a very popular sample – especially during the early phase of learning – the target score might be much lower than the sample score. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We concentrated on the gradients w.r.t. the target score, but a similar issue can be observed for the gradients on the negative scores. The gradient w.r.t. the score of a negative sample is the gradient of the pairwise loss between the target and the sample divided by the number of negative samples. This means that even if all negative samples would be relevant, their updates would still diminish as their number grows. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e39714c3915770892e4cac5001816899b5434c82313e30bf2c08752cc04ff57.jpg",
+        "image_caption": [
+            "Figure 2: Median negative gradients of BPR and BPR-max w.r.t. the target score against the rank of the target item. Left: only minibatch samples are used (minibatch size: 32); Center: 2048 additional negative samples were added to the minibatch samples; Right: same setting as the center, focusing on ranks 0-200. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            486,
+            790,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 RANKING-MAX LOSS FUNCTION FAMILY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            493,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To overcome the vanishing of gradients as the number of samples increase, we propose a new family of listwise loss functions, based on individual pairwise losses. The idea is to have the target score compared with the most relevant sample score, which is the maximal score amongst the samples. The general structure of the loss is described by (8). ",
+        "bbox": [
+            173,
+            747,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d667d5370e5a563eaf2e3f1bdbaf1bf9400d5c6aa7b2a4eb6730a1f70f180cc.jpg",
+        "text": "$$\nL _ { \\mathrm { p a i r w i s e - m a x } } \\left( r _ { i } , \\{ r _ { j } \\} _ { j = 1 } ^ { N _ { S } } \\right) = L _ { \\mathrm { p a i r w i s e } } ( r _ { i } , \\operatorname* { m a x } _ { j } r _ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            821,
+            674,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The maximum selection is non-differentiable and thus cannot be used with gradient descent. Therefore we use the softmax scores to preserve differentiability. Here, the softmax transformation is only used on the negative examples (i.e. $r _ { i }$ is excluded), since we are looking from the maximum score amongst the negative examples. This naturally results in loss functions where each negative sample is taken into account proportional to its likelihood of having the maximal score. Based on this general idea, we now derive the TOP1-max and BPR-max loss functions. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "TOP1-max: The TOP1-max loss is fairly straightforward. The regularizing part does not necessarily need to be only applied for the maximal negative score, however we found that this gave the best results, thus kept it this way. The continuous approximation to the maximum selection entails summing over the individual losses weighted by the corresponding softmax scores $s _ { j }$ , giving us the TOP1-max loss (9). ",
+        "bbox": [
+            173,
+            193,
+            825,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fda54d41452655af14c860a3c53034bfc16d375d1024567379a18807455d9c8e.jpg",
+        "text": "$$\nL _ { \\mathrm { t o p 1 - m a x } } = \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\left( \\sigma ( r _ { j } - r _ { i } ) + \\sigma ( r _ { j } ^ { 2 } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            281,
+            640,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The gradient of TOP1-max (10) is the softmax weighted average7 of individual pairwise gradients. If $r _ { j }$ is much lower than the maximum of negative scores, its weight will be almost zero and more weight will be placed on examples with scores close to the maximum. This solves the issue of vanishing gradients with more samples, because irrelevant samples will be just ignored, while the gradient will point towards the gradient of the relevant samples. Of course, if all samples are irrelevant, the gradient becomes near zero, but this is not a problem, since if the target score is greater than all sample scores, there is nothing to be learned. Unfortunately, the sensitivity to large sample scores of TOP1 is still an issue as it is the consequence of the pairwise loss and not the aggregation. ",
+        "bbox": [
+            173,
+            334,
+            825,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e27c107d4aece3fe5143c0594c3ecbffa3a459376d736ea1d75c4bb160e84d64.jpg",
+        "text": "$$\n\\frac { \\partial L _ { \\mathrm { t o p 1 - m a x } } } { \\partial \\boldsymbol { r } _ { i } } = - \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma ( \\boldsymbol { r } _ { j } - \\boldsymbol { r } _ { i } ) \\left( 1 - \\sigma ( \\boldsymbol { r } _ { j } - \\boldsymbol { r } _ { i } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            464,
+            673,
+            510
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "BPR-max: Going back to the probability interpretation of BPR, the goal is to maximize the probability of the target score being higher than the maximal sample score $r _ { \\operatorname* { m a x } } = \\operatorname* { m a x } _ { j } r _ { j }$ . This can be rewritten using conditional probabilities: ",
+        "bbox": [
+            174,
+            517,
+            825,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb0daf9963515562ff9d241e60724b2bfb6a39e8b1f4c77b7b6852e5833984ac.jpg",
+        "text": "$$\nP ( r _ { i } > r _ { \\operatorname* { m a x } } ) = \\sum _ { j = 1 } ^ { N _ { S } } P ( r _ { i } > r _ { j } | r _ { j } = r _ { \\operatorname* { m a x } } ) P ( r _ { j } = r _ { \\operatorname* { m a x } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            577,
+            691,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$P ( r _ { i } > r _ { j } )$ and $P ( r _ { j } = r _ { \\operatorname* { m a x } } )$ is approximated by $\\sigma ( r _ { i } - r _ { j } )$ (as in the original BPR loss) and the softmax score $s _ { j }$ respectively. We then want to minimize the negative log-probability, which gives us the loss: ",
+        "bbox": [
+            174,
+            631,
+            825,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f93fd23979bd173189a6ad169f353ee7b785ac6831438e91ff04be0c18c6a435.jpg",
+        "text": "$$\nL _ { \\mathrm { b p r - m a x } } = - \\log \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma ( r _ { i } - r _ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            690,
+            619,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The gradient of BPR-max (13) is the weighted average of individual BPR gradients, where the weights are $s _ { j } \\sigma ( r _ { i } - r _ { j } )$ . The relative importance of negative samples $j$ and $k$ is $\\begin{array} { r } { \\frac { \\sigma ( r _ { i } - r _ { j } ) s _ { j } } { \\sigma ( r _ { i } - r _ { k } ) s _ { k } } = } \\end{array}$ erj +e−ri+rj+rkerk +e−ri+rj+rk , which behaves like softmax weights if ri \u001d rj + rk or if both ri and rk are small. Otherwise it is a smoothed softmax. This means that while $r _ { i }$ is small, the weights are distributed more evenly, yet clear emphasis will be given to higher sample scores. As $r _ { i }$ becomes higher, the focus shifts quickly to the samples with high scores. This is an ideal behaviour. ",
+        "bbox": [
+            173,
+            743,
+            826,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da866da5bd675db6af66ea5fb6e4e6b4995a319280461d0e66b547537e51799d.jpg",
+        "text": "$$\n\\frac { \\partial L _ { \\mathrm { b p r - m a x } } } { \\partial \\boldsymbol { r } _ { i } } = - \\frac { \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma \\big ( \\boldsymbol { r } _ { i } - \\boldsymbol { r } _ { j } \\big ) \\left( 1 - \\sigma \\big ( \\boldsymbol { r } _ { i } - \\boldsymbol { r } _ { j } \\big ) \\right) } { \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma \\big ( \\boldsymbol { r } _ { i } - \\boldsymbol { r } _ { j } \\big ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            857,
+            678,
+            902
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The gradient w.r.t. a negative sample – with both the BPR-max and TOP1-max – is proportional to the softmax score of the example, meaning that only the items, near the maximum will be updated. This is beneficial, because if the score of a negative sample is low, it doesn’t need to be updated. If the score of a sample is much higher than that of the others it will be the only one updated and the gradient will coincide with the gradient of the pairwise loss between the target and the sample score. In a more balanced setting the gradient is between the aforementioned gradient and 0. For example the gradient of BPR-max w.r.t. a negative sample’s score is as follows: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9f2d75571af6a79353a8cb44126de9695f648a767b07de2042cfe44d8bc0945.jpg",
+        "text": "$$\n\\frac { \\partial L _ { \\mathrm { b p r - m a x } } } { \\partial \\boldsymbol { r } _ { k } } = s _ { k } - \\frac { s _ { k } \\sigma ^ { 2 } ( \\boldsymbol { r } _ { i } - \\boldsymbol { r } _ { k } ) } { \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma ( \\boldsymbol { r } _ { i } - \\boldsymbol { r } _ { j } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            217,
+            635,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 depicts how the gradients of BPR and BPR-max behave given the rank of the target item8. The rank of the target is the number of negative scores exceeding it, e.g. rank 0 means that the target score is higher than all sample scores. Lower rank means that there are fewer negative samples that are relevant. The figure depicts the median negative gradient w.r.t. the target score in two cases, measured on a dataset sample during the $1 ^ { s t }$ and $1 0 ^ { t h }$ epochs (i.e. beginning and end of the training): (left) no additional samples were used, only the other examples from a mini-batch of size 32; (middle & right) 2048 additional negative samples were added. The rightmost figure focuses on the first 200 ranks of the figure in the middle. The gradient is slightly higher for BPR when there are more relevant samples (i.e. high ranks). This is natural, since BPR-max focuses on samples closest to the maximum value and ignores other still relevant samples. This entails slightly slower learning for BPR-max when the target item is ranked at the end of the list, but the difference is not really significant. On the other hand, the gradient of BPR quickly vanishes as the number of relevant samples decrease (i.e. low ranks). The point of vanishing is relative to the total sample size. With small sample size, BPR’s gradient starts vanishing around rank 5 (the BPR-max does not vanish until rank 0); meanwhile, with more samples, the BPR gradient is very low, even for rank 100-500 (again, the gradient BPR-max starts decreasing significantly later). This means that BPR can hardly push target scores up in the ranking after a certain point, which comes earlier as the number of sample size increases. BPR-max, on the other hand, behaves well and is able to improve the score all the way. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 BPR-MAX WITH SCORE REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            546,
+            521,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Even though we showed that the heuristic TOP1 loss is sensitive to relevant samples with very high scores, it was found to be performing better than BPR in Hidasi et al. (2016a). According to our observation, the same is true for the relation of TOP1-max and BPR-max. Part of the reasons lies in the rare occurrence of $r _ { j } \\gg r _ { i }$ while $r _ { j } \\approx 0$ simultaneously. If only the first condition is met, the gradient w.r.t. $r _ { i }$ might vanish, but the regularizing part of TOP1 makes sure that $r _ { j }$ is moved towards zero, which might even make the update possible for $r _ { i }$ next time (e.g. if $r _ { j }$ was negative, moving it towards zero decreases the difference with $r _ { i }$ ). The score regularization in TOP1 is very beneficial to the overall learning process, so even though the loss might not be theoretically optimal, it can achieve good results. GRU4Rec support two forms of regularization with every loss: dropout and $\\ell _ { 2 }$ regularization of the model parameters. The regularization of TOP1 is used on the top of these. According to our experiments, the $\\ell _ { 2 }$ regularization of model parameters decreases the model performance. Our assumption is that some of the model weights – such as the weight matrices for computing the update and reset gate – should not be regularized. Penalizing high output scores takes care of constraining the model, even without explicitly regularizing the weights. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Therefore we added score regularization to the BPR-max loss function as well. We tried several ways of score regularization. In the best performing one we conditioned the sample scores on independent, zero mean Gaussians with variance inversely proportional to the softmax score (15). This entails stronger regularization on scores closer to the maximum, which is ideal in our case. ",
+        "bbox": [
+            176,
+            771,
+            823,
+            828
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16815e3f6a5f995e057abab2d8db523d0a6495fc01d2ff3a2a89c76c99980469.jpg",
+        "text": "$$\nP \\left( r _ { i } > r _ { \\mathrm { m a x } } | \\{ r _ { j } \\} _ { j = 1 } ^ { N _ { S } } \\right) \\prod _ { j = 1 } ^ { N _ { S } } P ( r _ { j } ) = P \\left( r _ { i } > r _ { \\mathrm { m a x } } | \\{ r _ { j } \\} _ { j = 1 } ^ { N _ { S } } \\right) \\prod _ { j = 1 } ^ { N _ { S } } \\mathcal { N } \\left( 0 , \\frac { c } { s _ { j } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            844,
+            758,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We minimize the negative log-probability and do continuous approximations as before, resulting in the final form of the BPR-max loss function (16). The regularization term is a simple, softmax weighted $\\ell _ { 2 }$ regularization over the scores. $\\lambda$ is the regularization hyperparameter of the loss. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2fea13cd0c47ee5e15875c085a396943f6c491887e4eebdd76b812b0644ca7f.jpg",
+        "text": "$$\nL _ { \\mathrm { b p r - m a x } } = - \\log \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } \\sigma ( r _ { i } - r _ { j } ) + \\lambda \\sum _ { j = 1 } ^ { N _ { S } } s _ { j } r _ { j } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            171,
+            665,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            238,
+            326,
+            255
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup: We evaluated the proposed improvements – fixed cross-entropy loss, rankingmax loss functions & adding additional samples – on four dataset. RSC15 is based on the dataset of RecSys Challange $2 0 1 5 ^ { 9 }$ , which contains click and buy events from an online webshop. We only kept the click data. VIDEO and VIDXL are proprietary datasets containing watch events from an online video service. Finally, CLASS is a proprietary dataset containing item page view events from an online classified site. Datasets were subjugated to minor preprocessing then split into train and test sets so that a whole session either belongs to the train or to the test set. The split is based on the time of the first event of the sessions. The datsets and the split are exactly the same for RSC15 as in Hidasi et al. (2016a); and for VIDXL and CLASS as in Hidasi et al. (2016b). VIDEO is of the same source as in Hidasi et al. (2016a), but a slightly different subset. Table 1 overviews the main properties of the datasets. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e21d2199b03c906b085876a29d921c8aee4c37d38fa5e892e13ae6cde036661.jpg",
+        "table_caption": [
+            "Table 1: Properties of the datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data</td><td colspan=\"2\">Train set</td><td colspan=\"2\">Test set</td><td>Items</td></tr><tr><td></td><td>Sessions</td><td>Events</td><td>Sessions</td><td>Events</td><td></td></tr><tr><td>RSC15</td><td>7,966,257</td><td>31,637,239</td><td>15,324</td><td>71,222</td><td>37,483</td></tr><tr><td>VIDEO</td><td>2,144,930</td><td>10,214,429</td><td>29,804</td><td>153,157</td><td>262.050</td></tr><tr><td>VIDXL</td><td>17,419,964</td><td>69,312,698</td><td>216,725</td><td>921,202</td><td>712,824</td></tr><tr><td>CLASS</td><td>1,173.094</td><td>9,011,321</td><td>35,741</td><td>254,857</td><td>339.055</td></tr></table>",
+        "bbox": [
+            330,
+            473,
+            666,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Evaluation is done under the next item prediction scenario, that is we iterate over test sessions and events therein. For each event, the algorithm guesses the item of the next event of that session. Since the size of the VIDXL test set is large, we compare the target item’s score to that of the $5 0 , 0 0 0 \\mathrm { m o s t }$ popular items during testing, similarly to Hidasi et al. (2016b). While this evaluation for VIDXL overestimates the performance, the comparison of algorithms remain fair Bellogin et al. (2011). As recommender systems can only recommend a few items at once, the actual item a user might pick should be amongst the first few items of the list. Therefore, our primary evaluation metric is recall $\\textcircled{ a} 2 0$ that is the proportion of cases having the desired item amongst the top-20 items in all test cases. Recall does not consider the actual rank of the item as long as it is amongst the top-N. This models certain practical scenarios well where there is no highlighting of recommendations and the absolute order does not matter. Recall also usually correlates well with important online KPIs, such as click-through rate (CTR)Liu et al. (2012); Hidasi & Tikk (2012). The second metric used in the experiments is MRR $@ 2 0$ (Mean Reciprocal Rank). That is the average of reciprocal ranks of the desired items. The reciprocal rank is set to zero if the rank is above 20. MRR takes into account the rank of the item, which is important in cases where the order of recommendations matter (e.g. the lower ranked items are only visible after scrolling). ",
+        "bbox": [
+            174,
+            561,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The natural baseline we use is the original GRU4Rec algorithm, upon which we aim to improve. We consider the results with the originally proposed TOP1 loss and tanh activation function on the output to be the baseline. The hidden layer has 100 units. We also indicate the performance of item-kNN, a natural baseline for next item prediction. Results for RSC15, VIDXL and CLASS are taken directly from corresponding papers Hidasi et al. (2016a;b) and measured with the optimal hyperparameters in Hidasi et al. (2016a) for VIDEO. We do separate hyperparameter optimization on a separate validation set for the proposed improvements. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The methods are implemented under the Theano framework Al-Rfou et al. (2016) in python. Experiments were run on various GPUs, training times were measured on an unloaded Titan X (Maxwell) GPU. Code is available publicly on GitHub10 for reproducibility. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.1 USING ADDITIONAL SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            165,
+            421,
+            178
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The first set of experiments examines the effect of additional negative samples on recommendation accuracy. Experiments were performed on the CLASS and the VIDEO datasets. Since results are quite similar we excluded the VIDEO results to save some space. Figure 3a depicts the performance of the network with TOP1, cross-entropy, TOP1-max and BPR-max losses. Recommendation accuracy was measured with different number of additional samples, as well as in the case when all scores are computed and there is no sampling. As we discussed earlier, this latter scenario is a more theoretical one, because it is not scalable. As theory suggests (see Section 3), the TOP1 loss does not cope well with lots of samples. There is a slight increase in performance with a few extra samples, as the chance of having relevant samples increases; but performance quickly degrades as sample size grow, thus lots of irrelevant samples are included. On the other hand, all three of the other losses react well to adding more samples. The point of diminishing return is around a few thousand of extra samples for cross-entropy. TOP1-max starts to slightly lose accuracy after that. BPR-max improves with more samples all the way, but slightly loses accuracy when all items are used. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/f1f35c240d5f7b29320f1efa0f732beedc675609e96f1d477d3b27928aece7c6.jpg",
+        "image_caption": [
+            "Figure 3: Results on the CLASS dataset. ”ALL” means no sampling of items. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            386,
+            761,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adding extra samples increase computational cost, yet due to easy parallelization on modern GPUs most of this cost is alleviated. Figure 3b shows the training times at different sample sizes. Please note the logarithmic scale. The actual training time depends on not just the dataset, but model parameters (especially mini-batch size) and how certain operators used for computing the loss are supported by the framework. The trend, however, is similar to for all losses. For example, the full training of the network is around 10 minutes (with the settings for cross-entropy or TOP1-max), which does not increase with even 512 extra samples. At the point of diminishing returns, i.e. at 2048 extra samples, training time is around 15 minutes, which is also totally acceptable. After that, training times grow quickly, due to exceeding the parallelization capabilities of the GPU we used. The trend is similar on the VIDEO dataset, with training times starting around 50 minutes, starting to increase at 2048 extra samples (to 80 minutes) and quickly above thereafter. This means that the proposed method can be used with zero too little additional cost in practice, unlike data augmentation methods. It is also clear that GRU4Rec can work just as well with a few thousands of negative examples as with the whole itemset, thus it can be kept scalable. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In the next experiment we perform a parameter sensitivity analysis of the $\\alpha$ parameter that controls the sampling. Figure 4 depicts the performance over different $\\alpha$ values for the cross-entropy, TOP1- max and BPR-max losses. Cross-entropy favors higher $\\alpha$ values with low sample sizes and low $\\alpha$ values for large samples. This is inline with our discussion in Section 2: popular samples are useful when the sample size is very limited and at the beginning of the training, but might be exhausted quickly, thus switching to a more balanced sampling can be beneficial if we have the means to (e.g. large enough sample size). Also, the uniform sampling in this case is supplemented by the few popularity based samples of the mini-batch sampling. The ranking-max losses, on the other hand, seem to prefer the middle road with a slight preference towards higher values, while the extremes perform the worst. We assume that this is mostly due to (a) being based on pairwise losses, where popular samples are usually desired; (b) and the score regularization: with popularity based sampling the scores of the most popular items would be decreased beyond what is desirable. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/346620a270a18c8f1e066a9ecc336da9567ec1c2673711f73bc43cc95f5c763c.jpg",
+        "image_caption": [
+            "Figure 4: The effect of the alpha parameter on recommendation accuracy at different sample sizes on the CLASS dataset. Left: cross-entropy loss; Middle: TOP1-max loss; Right: BPR-max loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            97,
+            807,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/c692669f05aaff49aded38e9ff897bab724f4ebcee02fcf3a50d15da50f78100.jpg",
+        "table_caption": [
+            "Table 2: Recommendation accuracy with additional samples and different loss functions compared to item-kNN and the original GRU4Rec. Improvements over item-kNN and the original GRU4Rec (with TOP1 loss) results are shown in parentheses. Best results are typeset bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Item kNN</td><td colspan=\"2\">GRU4Rec original</td><td colspan=\"4\">GRU4Rec with additional samples</td></tr><tr><td></td><td>XE</td><td>TOP1</td><td>XE</td><td>TOP1-max</td><td>BPR-max</td></tr><tr><td colspan=\"8\">Recall@20</td></tr><tr><td>RSC15</td><td>0.5065</td><td>0.5853</td><td>0.5781</td><td>0.6117 (+20.77%,+4.51%)</td><td>0.7112 (+40.41%,+21.51%)</td><td>0.7086 (+39.91%,+21.07%)</td><td>0.7190 (+41.95%,+22.84%)</td></tr><tr><td>VIDEO VIDXL</td><td>0.5201</td><td>0.5051</td><td>0.5060</td><td>0.5325 (+2.40%,+5.43%)</td><td>0.6222 (+19.63%,+23.18%)</td><td>0.6421 (+23.46%,+27.12%)</td><td>0.6524 (+25.44%,+29.16%)</td></tr><tr><td>CLASS</td><td>0.6263 0.2201</td><td>0.6831 0.2478</td><td>0.7046 0.2545</td><td>0.6723 (+7.35%,-1.58%) 0.2342 (+6.41%,-5.50%)</td><td>0.7972 (+27.29%,+16.70%) 0.3099 (+40.83%,+25.07%)</td><td>0.7935 (+26.70%,+16.16%) 0.3252 (+47.75%,+31.22%)</td><td>0.8020 (+28.05%,+17.41%) 0.3342 (+51.84%,+34.87%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan=\"8\">MRR@20</td></tr><tr><td>RSC15</td><td>0.2048</td><td>0.2305</td><td>0.2375</td><td>0.2367 (+15.61%,+2.69%)</td><td>0.3059 (+49.41%,+32.71%)</td><td>0.3045 (+48.70%,+32.08%)</td><td>0.3119 (+52.29%,+35.31%)</td></tr><tr><td>VIDEO VIDXL</td><td>0.2257</td><td>0.2359</td><td>0.2609</td><td>0.2295 (+1.69%,-2.73%)</td><td>0.2970 (+31.63%,+25.92%)</td><td>0.2950 (+30.72%,+25.05%)</td><td>0.3019 (+33.76%, +27.98%)</td></tr><tr><td>CLASS</td><td>0.3740</td><td>0.3847</td><td>0.4343</td><td>0.3608 (-3.53%,-6.21%)</td><td>0.5023 (+34.31%, +30.59%)</td><td>0.4939 (+32.05%,+28.39%)</td><td>0.5013 (+34.01%,+30.30%)</td></tr><tr><td></td><td>0.0799</td><td>0.0949</td><td>0.0995</td><td>0.0870 (+8.83%,-8.36%)</td><td>0.1176 (+47.14%,+23.90%)</td><td>0.1198 (+49.93%,+26.25%)</td><td>0.1207 (+51.06%,+27.19%)</td></tr></table>",
+        "bbox": [
+            173,
+            428,
+            901,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4.2 LOSS-FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            338,
+            607
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We measure the performance gain of the proposed improvements over the baselines. The big accuracy improvement comes from the combination of additional samples and the loss functions (fixed cross-entropy, TOP1-max and BPR-max). Table 2 showcases our most important results. Besides the original version of GRU4Rec and the item-kNN, we included results with cross-entropy (XE) loss without additional sampling to confirm that the fixed cross-entropy loss still performs just slightly better than TOP1. The increase with sampling and the proper loss function is stunning as the best results exceed the accuracy of the original GRU4Rec by $1 5 - 3 5 \\%$ and that of item-kNN by up to $5 2 \\%$ . BPR-max even performs slightly better $( + 1 - 7 \\% )$ than cross-entropy on 3 of 4 datasets and achieves similar results on the remaining one dataset. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            744
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "On RSC15, Tan et al. (2016) reported $\\sim 0 . 6 8 5$ and $\\sim 0 . 2 9$ in recall $@ 2 0$ and MRR $\\textcircled{ a} 2 0$ respectively11 using data augmentation. Unlike our solutions, data augmentation greatly increases training times. Data augmentation and our improvements are not mutually exclusive, thus it is possible that combining the two methods, even better results can be achieved. A very recent paper Chatzis et al. (2017) proposes the Bayesian version of GRU4Rec and reports $\\sim 0 . 6 1$ and $\\sim 0 . 2 5$ in recall $\\textcircled{ a} 2 0$ and MRR $@ 2 0$ when using 100 units12. Therefore our GRU4Rec version is the current best performer so far. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/82da062ab049b0841798f5183c9a4862238d043fe4ee1b718dc6c40ace112741.jpg",
+        "table_caption": [
+            "Table 3: Results with unified embeddings "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Recall@20</td><td>MRR@20</td></tr><tr><td>RSC15</td><td>0.7220</td><td>0.3070</td></tr><tr><td>VIDEO</td><td>0.6612</td><td>0.2923</td></tr><tr><td>VIDXL</td><td>0.8045</td><td>0.4915</td></tr><tr><td>CLASS</td><td>0.3844</td><td>0.1471</td></tr></table>",
+        "bbox": [
+            406,
+            127,
+            589,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4.3 UNIFIED ITEM REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            210,
+            446,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Previous experiments did not find any benefits of using an embedding layer before the GRU layers. The role of the embedding layer is to translate item IDs into the latent representation space. In the recommender systems terminology, item embeddings correspond to “item feature vectors”. The network has another “item feature matrix” in the form of the output weight matrix. By unifying the representations, i.e. sharing the weight matrix between the embedding layer and the output layer, we learn better item representations quicker. Preliminary experiments (Table 3) show additional improvements in recall $\\textcircled{ a} 2 0$ and slight decrease in $\\mathbf { M R R } @ 2 0$ for most of the datasets, however, for the CLASS dataset both recall and MRR are increased significantly when unified embeddings are used $( + 1 5 . 0 2 \\%$ and $+ 2 1 . 8 7 \\%$ in recall and MRR respectively, compared to the model trained without embeddings). ",
+        "bbox": [
+            174,
+            236,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            395,
+            318,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We introduced a new class of loss function that together with an improved sampling strategy have provided impressive top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ gains for RNNs for session-based recommendations. We believe that these new losses could be more generally applicable and along with the corresponding sampling strategies also provide top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ gains for different recommendations settings and algorithms such as e.g. matrix factorization or autoencoders. It is also conceivable that these techniques could also provide similar benefits in the area of Natural Language Processing a domain that shares significant similarities to the recommendation domain in terms of machine learning (e.g. ranking, retrieval) and data structure (e.g. sparse large input and output space). ",
+        "bbox": [
+            173,
+            425,
+            825,
+            537
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            285,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rami Al-Rfou, Guillaume Alain, Amjad Almahairi, Christof Angermueller, Dzmitry Bahdanau, Nicolas Ballas, Fred´ eric Bastien, Justin Bayer, Anatoly Belikov, Alexander Belopolsky, et al. ´ Theano: A python framework for fast computation of mathematical expressions. arXiv preprint arXiv:1605.02688, 2016.   \nAlejandro Bellogin, Pablo Castells, and Ivan Cantador. Precision-oriented evaluation of recommender systems: An algorithmic comparison. In RecSys’11: 5th ACM Conf. on Recommender Systems, pp. 333–336, 2011. ISBN 978-1-4503-0683-6. doi: 10.1145/2043932.2043996. URL http://doi.acm.org/10.1145/2043932.2043996.   \nChris J.C. Burges. From ranknet to lambdarank to lambdamart: An overview. Technical report, June 2010. URL https://www.microsoft.com/en-us/research/publication/ from-ranknet-to-lambdarank-to-lambdamart-an-overview/.   \nSotirios Chatzis, Panayiotis Christodoulou, and Andreas S Andreou. Recurrent latent variable networks for session-based recommendation. arXiv preprint arXiv:1706.04026, 2017.   \nKyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder–decoder approaches. In SSST-8: 8th Workshop on Syntax, Semantics and Structure in Statistical Translation, pp. 103–111, 2014.   \nRobin Devooght and Hugues Bersini. Collaborative filtering with recurrent neural networks. arXiv preprint arXiv:1608.07400, 2016.   \nB. Hidasi and D. Tikk. Fast ALS-based tensor factorization for context-aware recommendation from implicit feedback. In ECML-PKDD’12, Part II, number 7524 in LNCS, pp. 67–82. Springer, 2012. ",
+        "bbox": [
+            171,
+            579,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Balazs Hidasi, Alexandros Karatzoglou, Linas Baltrunas, and Domonkos Tikk. Session-based rec- ´ ommendations with recurrent neural networks. International Conference on Learning Representations, 2016a. URL http://arxiv.org/abs/1511.06939. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Balazs Hidasi, Massimo Quadrana, Alexandros Karatzoglou, and Domonkos Tikk. Parallel recurrent ´ neural network architectures for feature-rich session-based recommendations. In Proceedings of the 10th ACM Conference on Recommender Systems, RecSys ’16, pp. 241–248, New York, NY, USA, 2016b. ACM. ISBN 978-1-4503-4035-9. doi: 10.1145/2959100.2959167. URL http: //doi.acm.org/10.1145/2959100.2959167. ",
+        "bbox": [
+            173,
+            155,
+            826,
+            224
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            234,
+            823,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shihao Ji, SVN Vishwanathan, Nadathur Satish, Michael J Anderson, and Pradeep Dubey. Blackout: Speeding up recurrent neural network language models with very large vocabularies. ICLR, 2016. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            301
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yehuda Koren and Joe Sill. Ordrec: An ordinal model for predicting personalized item rating distributions. In Proceedings of the Fifth ACM Conference on Recommender Systems, RecSys ’11, pp. 117–124, New York, NY, USA, 2011. ACM. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "G. Linden, B. Smith, and J. York. Amazon.com recommendations: Item-to-item collaborative filtering. Internet Computing, IEEE, 7(1):76–80, 2003. ",
+        "bbox": [
+            176,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qiwen Liu, Tianjian Chen, Jing Cai, and Dianhai Yu. Enlister: Baidu’s recommender system for the biggest Chinese Q&A website. In RecSys-12: Proc. of the 6th ACM Conf. on Recommender Systems, pp. 285–288, 2012. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S. Rendle, C. Freudenthaler, Z. Gantner, and L. Schmidt-Thieme. BPR: Bayesian personalized ranking from implicit feedback. In UAI’09: $2 5 ^ { t h }$ Conf. on Uncertainty in Artificial Intelligence, pp. 452–461, 2009a. ISBN 978-0-9749039-5-8. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            493
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Steffen Rendle, Christoph Freudenthaler, Zeno Gantner, and Lars Schmidt-Thieme. Bpr: Bayesian personalized ranking from implicit feedback. In Proceedings of the Twenty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI ’09, pp. 452–461, 2009b. ",
+        "bbox": [
+            173,
+            502,
+            823,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Badrul Sarwar, George Karypis, Joseph Konstan, and John Riedl. Item-based collaborative filtering recommendation algorithms. In WWW:01: 10th Int. Conf. on World Wide Web, pp. 285–295, 2001. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yue Shi, Alexandros Karatzoglou, Linas Baltrunas, Martha Larson, Nuria Oliver, and Alan Hanjalic. Climf: Learning to maximize reciprocal rank with collaborative less-is-more filtering. In Proceedings of the Sixth ACM Conference on Recommender Systems, RecSys ’12, pp. 139–146, 2012. ISBN 978-1-4503-1270-7. doi: 10.1145/2365952.2365981. URL http://doi.acm. org/10.1145/2365952.2365981. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            676
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yong Kiam Tan, Xinxing Xu, and Yong Liu. Improved recurrent neural networks for session-based recommendations. In Proceedings of the 1st Workshop on Deep Learning for Recommender Systems, DLRS 2016, pp. 17–22, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4795- 2. doi: 10.1145/2988450.2988452. URL http://doi.acm.org/10.1145/2988450. 2988452. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            755
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Markus Weimer, Alexandros Karatzoglou, Quoc Viet Le, and Alex Smola. Cofirank maximum margin matrix factorization for collaborative ranking. In Proceedings of the 20th International Conference on Neural Information Processing Systems, NIPS’07, pp. 1593–1600, 2007. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recommender networks. In Proceedings of the Tenth ACM International Conference on Web Search and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM. ",
+        "bbox": [
+            176,
+            815,
+            825,
+            858
+        ],
+        "page_idx": 12
+    }
+]