Year: 2020

Abstract:
The efficient treatment of long-range interactions for point clouds is a challenging problem in many scientific machine learning applications. To extract global information, one usually needs a large window size, a large number of layers, and/or a large number of channels. This can often significantly increase the computational cost. In this work, we present a novel neural network layer that directly incorporates long-range information for a point cloud. This layer, dubbed the long-range convolutional (LRC)-layer, leverages the convolutional theorem coupled with the non-uniform Fourier transform. In a nutshell, the LRC-layer mollifies the point cloud to an adequately sized regular grid, computes its Fourier transform, multiplies the result by a set of trainable Fourier multipliers, computes the inverse Fourier transform, and finally interpolates the result back to the point cloud. The resulting global all-to-all convolution operation can be performed in nearly-linear time asymptotically with respect to the number of input points. The LRC-layer is a particularly powerful tool when combined with local convolution as together they offer efficient and seamless treatment of both short and long range interactions. We showcase this framework by introducing a neural network architecture that combines LRC-layers with short-range convolutional layers to accurately learn the energy and force associated with a N -body potential. We also exploit the induced two-level decomposition and propose an efficient strategy to train the combined architecture with a reduced number of samples.

heading: 1 INTRODUCTION
text: Point-cloud representations provide detailed information of objects and environments. The development of novel acquisition techniques, such as laser scanning, digital photogrammetry, light detection and ranging (LIDAR), 3D scanners, structure-from-motion (SFM), among others, has increased the interest of using point cloud representation in various applications such as digital preservation, surveying, autonomous driving (Chen et al., 2017), 3D gaming, robotics (Oh & Watanabe, 2002), and virtual reality (Park et al., 2008). In return, this new interest has fueled the development of machine learning frameworks that use point clouds as input. Historically, early methods used a preprocessing stage that extracted meticulously hand-crafted features from the point cloud, which were subsequently fed to a neural network (Chen et al., 2003; Rusu et al., 2008; Rusu et al., 2009; Aubry et al., 2011), or they relied on voxelization of the geometry (Savva et al., 2016; Wu et al., 2015; Riegler et al., 2017; Maturana & Scherer, 2015). The PointNet architecture (Qi et al., 2017) was the first to handle raw point cloud data directly and learn features on the fly. This work has spawned several related approaches, aiming to attenuate drawbacks from the original methodology, such as PointNet++ (Qi et al., 2017), or to increase the accuracy and range of application (Wang et al., 2019; Zhai et al., 2020; Li et al., 2018; Liu et al., 2019).
Even though such methods have been quite successful for machine learning problems, they rely on an assumption of locality, which may produce large errors when the underlying task at hand exhibits long-range interactions (LRIs). To capture such interactions using standard convolutional layers, one can use wider window sizes, deeper networks, and/or a large number of features, which may increase the computational cost significantly. Several approaches have been proposed to efficiently capture such interactions in tasks such as semantic segmentation, of which the ideas we briefly summarize below. In the multi-scale type of approaches, features are progressively processed and merged. Within this family, there exist several variants, where the underlying neural networks can
be either recursive neural networks (Ye et al., 2018), convolutional layers (Xu et al., 2019; Xu et al., 2018) or autoencoders (Yang et al., 2018; Deng et al., 2018). Some works have proposed skip connections, following an U-net (Ronneberger et al., 2015) type architecture (Zhou & Tuzel, 2018; Qi et al., 2017), while others have focused on using a tree structure for the clustering of the points (Klokov & Lempitsky, 2017; Zeng & Gevers, 2018; Gadelha et al., 2018), or using an reference permutohedral lattices to compute convolutions (Jampani et al., 2016) whose results are interpolated back to the point cloud (Su et al., 2018). Although these methods have been shown to be successful in a range of applications, when the task at hand presents symmetries, such as rotation, translation, and permutation invariance, there is no systematic framework to embed those symmetries into the algorithmic pipelines. Another line of work, relies on interpreting the point cloud as a graph and use spectral convolutions (Bruna et al.; Defferrard et al., 2016), whose cost can scale super-linearly when dealing with LRIs.
In applications of machine learning to scientific computing, several classical multilevel matrix factorizations have been rewritten in the context of machine learning (Kondor et al., 2014), which have been adapted to handle long-range interactions in the context of end-to-end maps using voxelized geometries in (Fan et al., 2019b;a; Khoo & Ying, 2019; Fan & Ying, 2019) resulting in architectures similar to U-nets (Ronneberger et al., 2015), which have been extended to point clouds in (Li et al., 2020). Due to underlying voxelization of the geometry, it may be difficult for these networks to generalize when the resolution of the voxelization changes.
The efficient treatment of LRI for point clouds is also a prominent problem in many physical applications such as molecular modeling and molecular dynamics simulation. While long-range electrostatic interactions are omnipresent, it has been found that effectively short-ranged models can already describe the N -body potential and the associated force field (Behler & Parrinello, 2007; Zhang et al., 2018a;b) for a wide range of physical systems. There have also been a number of recent works aiming at more general systems beyond this regime of effective short-range interactions, such as the work of Ceriotti and co-workers (Grisafi & Ceriotti, 2019; Grisafi et al.; Nigam et al., 2020; Rossi et al., 2020), as well as the works of (Yao et al., 2018; Ko et al., 2009; Hirn et al., 2017; Rupp et al., 2012; Huo & Rupp; Deng et al., 2019; Bereau et al., 2018; Zhang et al., 2019). The general strategy is to build parameterized long-range interactions into the kernel methods or neural network models, so that the resulting model can characterize both short-range, as well as long-range electrostatic interactions. In the neural network context, the computational cost of treating the LRIs using these methods can grow superlinearly with the system size.
The idea of this work is aligned with the approaches in the molecular modeling community, which constructs a neural network layer to directly describe the LRI. In particular, we present a new longrange convolutional (LRC)-layer, which performs a global convolutional operation in nearly-linear time with respect to number of units in the layer. By leveraging the non-uniform Fourier transform (NUFFT) (Dutt & Rokhlin, 1993; Greengard & Lee, 2004; Barnett et al., 2019) technique, the LRC-layer implements a convolution with a point-wise multiplication in the frequency domain with trainable weights known as Fourier multipliers. The NUFFT is based on the regular fast Fourier transform (FFT) (Cooley & Tukey, 1965) with a fast gridding algorithms, to allow for fast convolution on unstructured data. This new LRC-layer provides a new set of descriptors that can seamlessly satisfy relevant symmetries. For instance, when the kernel of the LRI is rotationally invariant, such symmetry can be directly built into the parameterization of the Fourier kernel. Such descriptors can be used in tandem with the descriptors provided by short-range convolutional layers to improve the performance of the neural network.
Efficient training of a neural network with the LRC-layer for capturing the information of LRIs is another challenging problem. Short-range models can often be trained with data generated with a relatively small computational box (called the small-scale data), and they can be seamlessly deployed in large-scale systems without significantly increasing the generalization error. On the other hand, long-range models need to be trained directly with data generated in a large computational box (called the large-scale data), and the generation process of such large-scale data can be very expensive. For instance, in molecular modeling, the training data is often generated with highly accurate quantum mechanical methods, of which the cost can scale steeply as O(Nα), where N is the system size and α ≥ 3. Therefore it is desirable to minimize the number of samples with a large system size. In many applications, the error of the effective short-range model is already modestly small. This motivates us to propose a two-scale training strategy as follows. We first generate many small-scale data (cheaply
and possibly in parallel), and train the network without the LRC-layer. Then we use a small number of large-scale data, and perform training with both the short- and long-range convolutional layers.
In order to demonstrate the effectiveness of the LRC-layer and the two-scale training procedure, we apply our method to evaluate the energy and force associated with a model N -body potential that exhibit tunable short- and long-range interactions in one, two and three dimensions. The input point cloud consists of the atomic positions, and the output data include the N -body potential, local potential, and the force (derivative of the N -body potential with respect to atomic positions). In particular, the local potential and the force can be viewed as point clouds associated with the atomic positions. The evaluation of the N -body potential is a foundational component in molecular modeling, and LRI plays an important role in the description of ionic systems, macroscopically polarized interfaces, electrode surfaces, and many other problems in nanosciences (French et al., 2010). Our result verifies that the computational cost of the long-range layer can be reduced from O(N2) using a direct implementation, to O(N) (up to logarithmic factors) using NUFFT. Furthermore, we demonstrate that the force, i.e. the derivatives of the potential with respect to all inputs can be evaluated with O(N) cost (up to logarithmic factors). In terms of sample efficiency, we find that for the model problem under study here, the two-scale training strategy can effectively reduce the number of large-scale samples by over an order of magnitude to reach the target accuracy. This can be particularly valuable in the context of molecular modeling, where accurate data are often obtained from first principle electronic structure calculations. Such calculations are often very expensive for large scale systems, and the number of large-scale samples is thus limited.

heading: 2 LONG-RANGE CONVOLUTIONAL LAYER
text: Convolutional layers are perhaps the most important building-block in machine learning, due to their great success in image processing and computer vision. A convolutional layer convolves the input, usually an array, with a rectangular mask containing the trainable parameters. When the mask can be kept small (for example while extracting localized features), the convolution layer is highly efficient and effective. A different way for computing a convolution is to use the convolutional theorem as follows: (1) compute the Fourier transform of the input, (2) multiply with the Fourier transform of the mask, i.e.m the Fourier multiplier, and (3) inverse Fourier transform back. In this case, the trainable parameters are the DOFs of the Fourier multipliers and the Fourier transforms are computed using the fast Fourier transform (FFT). This alternative approach is particularly attractive for smooth kernels with large support (i.e., smooth long-range interactions) because the computational cost does not increase with the size of the mask. To the best of our knowledge, this direction has not been explored for LRIs and below we detail now to apply this to point clouds.
Given a point cloud {xi}Ni=1 ⊂ Rd and scalar weights {fi}Ni=1, we consider the problem of computing the quantity ui := ∑N j=1 φθ(xi − xj)fj at each xi. Here the function φθ(·) is the kernel with a generic trainable parameter θ. At first glance the cost of this operation scales as O(N2): we need to evaluate ui for each point xi, which requiresO(N) work per evaluation. By introducing a generalized function f(y) = ∑ i fi · δ(y − xi) and defining a function u(x) = ∫ φθ(x− y)f(y)dy, one notices that ui is the value of u(x) at x = xi. The advantage of this viewpoint is that one can now invoke the connection between convolution and Fourier transform
û(k) = φ̂θ(k) · f̂(k), (1) where φ̂θ(k) is a trainable Fourier multiplier. This approach is suitable for point clouds since the trainable parameters are decoupled from the geometry of the point cloud. To make this approach practical, one needs to address two issues: (1) the non-uniform distribution of the point cloud and (2) how to represent the multiplier φ̂θ(k).
Non-uniform distribution of the point cloud Equation 1 suggests that one can compute the convolution directly using the convolution theorem, which typically relies on the FFT to obtain a low-complexity algorithm. Unfortunately, {xi}Ni=1 do not form a regular grid, thus FFT can not be directly used. We overcome this difficulty by invoking the NUFFT1 (Dutt & Rokhlin, 1993), which serves as the corner-stone of our instance of the LRC-layer2.
1See Appendix C.2 for further details. 2We point out, that one could in practice use an fast summation algorithm, such as the fast multipole method (FMM) introduced by Greengard & Rokhlin (1987), to evaluate ui. This would results in the same complexity if
Algorithm 1 Long-range convolutional layer Input: {xi}Ni=1, {fi}Ni=1 Output: {xi}Ni=1, {ui}Ni=1, where ui = ∑N j=1 fjφθ(xi − xj).
1: Define the generalized function: f(x) = ∑N j=1 fjδ(x− xj) 2: Mollify the Dirac deltas: fτ (x) = ∑N j=1 fjgτ (x− xj), where gτ is defined in Appendix C.2 3: Sample in a regular grid: fτ (x`) = ∑N j=1 gτ (x` − xj) for x` in grid of size LFFT in each dim 4: Compute FFT: Fτ (k) = FFT(fτ )(k) 5: Re-scale the signal: F (k) = √ π τ e k2τFτ (k) 6: Multiply by Fourier multipliers: v̂(k) = φ̂θ(k) · F (k) 7: Re-scale the signal: v̂−τ (k) = √ π τ e k2τ v̂(k) 8: Compute IFFT: u−τ (x`) = IFFT(v̂−τ )(x) for x` on the regular grid 9: Interpolate to the point cloud: ui = u(xi) = u−τ ∗ gτ (xi)
The LRC-layer is summarized in Alg. 1, where τ is chosen following Dutt & Rokhlin (1993). The inputs of this layer are the point cloud {xi}Ni=1 and the corresponding weights {fi}Ni=1. The outputs are ui ≡ u(xi) for i = 1, ..., N . The number of elements in the underlying grid NFFT = LdFFT is chosen such that the kernel is adequately sampled and the complexity remains low. As shown in Appendix C.5, one only needs a relatively small LFFT. Even though the precise number is problemspecific, given that the goal is to approximate LRIs that are supposedly smooth, it can be captured with a relatively small number of Fourier modes.
The LRC-layer is composed of three steps: (1) It computes the Fourier transform from the point cloud to a regular grid using the NUFFT algorithm (lines 2− 5 in Alg. 1 and showcased in Fig. 2). (2) It multiplies the result by a set of trainable Fourier multipliers (line 6 in Alg. 1). (3) It computes the inverse Fourier transform from the regular grid back to the point cloud (lines 7− 9 in Alg. 1). Within the LRC-layer in Alg. 1, the only trainable component is the parameter θ of the Fourier multiplier φ̂θ(k). The remaining components, including the mollifier gτ (·) and the Cartesian grid size, are taken to be fixed. One can, in principle, train them as well, but it comes with a much higher cost. Among the steps of Alg. 1, the sampling operator, the rescaling operator, the interpolation operator, and the Fourier transforms, are all linear and non-trainable. Therefore, derivative computations of backpropagation just go through them directly.
Alg. 1 is presented in terms of only one single channel or feature dimension, i.e., fj ∈ R and ui ∈ R. However, it can be easily generalized to multiple channels, for example fj ∈ Rd1 and ui ∈ Rd2 . In this case, the Fourier multiplier φ̂θ(k) at each point k is a d2 × d1 matrix, and all Fourier transforms are applied component-wise.
Representation of the Fourier multiplier A useful feature of the LRC-layer is that it is quite easy to impose symmetries on the Fourier multipliers. For example, if the convolution kernel φθ(·) is constrained to have parity symmetry, rotational symmetry, smoothness or decay properties, these constraints can be imposed accordingly on the coefficients of the Fourier multipliers φ̂θ(k). When the size of the training data is limited, it is often necessary to reduce the number of trainable parameters in order to regularize the kernel. For example, we may parameterize the Fourier multiplier as a linear combination of several predetermined functions on the Fourier grid. This is the procedure used in molecular modeling (Grisafi & Ceriotti, 2019; Yao et al., 2018; Ko et al., 2009), and also in our numerical examples in equation 7. We also remark that the LRC-layer described here can be applied to point clouds a way similar to a standard convolution layer applied to images and multiple LRC-layers can be composed on top of each other.
the kernel is fixed. However, in order for the kernel to be trainable, this would require a different algorithm for each iteration, including the computation of the derivatives, thus increasing the computational cost and rendering the implementation significantly more cumbersome.
Under review as a conference paper at ICLR 2021
<latexit sha1_base64="CzgOsCb5dn9rKCMHR0qbPmNYaK8=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0lEsceCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipGQ7KFbfqLkDWiZeTCuRoDMpf/WHM0gilYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZKmmE2s8Wh87IhVWGJIyVLWnIQv09kdFI62kU2M6ImrFe9ebif14vNWHNz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20r6redfWmeV2p1/I4inAG53AJHtxCHe6hAS1ggPAMr/DmPDovzrvzsWwtOPnMKfyB8/kDyoeM6A==</latexit>
<latexit sha1_base64="cf2V4AnIhRim/3JeHlwyQomsm9U=">AAAB6HicbVDLTgJBEOzFF+IL9ehlIjHxRHYNRo4kXjxCIo8ENmR26IWR2dnNzKyREL7AiweN8eonefNvHGAPClbSSaWqO91dQSK4Nq777eQ2Nre2d/K7hb39g8Oj4vFJS8epYthksYhVJ6AaBZfYNNwI7CQKaRQIbAfj27nffkSleSzvzSRBP6JDyUPOqLFS46lfLLlldwGyTryMlCBDvV/86g1ilkYoDRNU667nJsafUmU4Ezgr9FKNCWVjOsSupZJGqP3p4tAZubDKgISxsiUNWai/J6Y00noSBbYzomakV725+J/XTU1Y9adcJqlByZaLwlQQE5P512TAFTIjJpZQpri9lbARVZQZm03BhuCtvrxOWldlr1K+blRKtWoWRx7O4BwuwYMbqMEd1KEJDBCe4RXenAfnxXl3PpatOSebOYU/cD5/AOXPjPo=</latexit>
<latexit sha1_base64="9sT+zsi99ZHLmWbkwsJA3sBXKbw=">AAACHHicbVDLSgMxFM34rPU16tJNsAgVpMxoxW6EghtXUsE+oFNLJs20oZkHyR2xDPMhbvwVNy4UceNC8G/MtF1o64VwDufcy809biS4Asv6NhYWl5ZXVnNr+fWNza1tc2e3ocJYUlanoQhlyyWKCR6wOnAQrBVJRnxXsKY7vMz85j2TiofBLYwi1vFJP+AepwS01DVPHcE8cJIxFL1uwtNj/JCBI3l/AEcTcFItXdjpXXKd5rtmwSpZ48LzxJ6SAppWrWt+Or2Qxj4LgAqiVNu2IugkRAKngqV5J1YsInRI+qytaUB8pjrJ+LgUH2qlh71Q6hcAHqu/JxLiKzXyXd3pExioWS8T//PaMXiVTsKDKAYW0MkiLxYYQpwlhXtcMgpipAmhkuu/YjogklDQeWYh2LMnz5PGSckul85uyoVqZRpHDu2jA1RENjpHVXSFaqiOKHpEz+gVvRlPxovxbnxMWheM6cwe+lPG1w9426Iw</latexit>
<latexit sha1_base64="OigvCa5o4zDt9IMj06BI+xVCTFQ=">AAACGnicbVDLSgMxFM3UV62vUZdugkVoF5YZqdhNoeDGlVSwD2jHIZNm2rSZB0lGWob5Djf+ihsXirgTN/6NaTuIth4IHM45l5t7nJBRIQ3jS8usrK6tb2Q3c1vbO7t7+v5BUwQRx6SBAxbwtoMEYdQnDUklI+2QE+Q5jLSc0eXUb90TLmjg38pJSCwP9X3qUoykkmzddO24K1GUFMZFWIVdEXl2PKyayV18nUDXHsL+T+AUju1h0dbzRsmYAS4TMyV5kKJu6x/dXoAjj/gSMyRExzRCacWIS4oZSXLdSJAQ4RHqk46iPvKIsOLZaQk8UUoPugFXz5dwpv6eiJEnxMRzVNJDciAWvan4n9eJpFuxYuqHkSQ+ni9yIwZlAKc9wR7lBEs2UQRhTtVfIR4gjrBUbeZUCebiycukeVYyy6Xzm3K+VknryIIjcAwKwAQXoAauQB00AAYP4Am8gFftUXvW3rT3eTSjpTOH4A+0z2+P5Z/q</latexit>
<latexit sha1_base64="xBA9/PTg3eHQ5avpSkVxfJfaLOc=">AAACJXicbVDLSgMxFM3UV62vUZdugkVoF5YZqdiFhYIbV1LBPqAzDpk006bNPEgy0jLMz7jxV9y4sIjgyl8xfSy09UDgcM653NzjRowKaRhfWmZtfWNzK7ud29nd2z/QD4+aIow5Jg0cspC3XSQIowFpSCoZaUecIN9lpOUOb6Z+64lwQcPgQY4jYvuoF1CPYiSV5OjXnpNYEsVpYaQIYSwtwiq0ROw7yaBqpo/JXQp7yxl4DkfOoOjoeaNkzABXibkgebBA3dEnVjfEsU8CiRkSomMakbQTxCXFjKQ5KxYkQniIeqSjaIB8IuxkdmUKz5TShV7I1QsknKm/JxLkCzH2XZX0keyLZW8q/ud1YulV7IQGUSxJgOeLvJhBGcJpZbBLOcGSjRVBmFP1V4j7iCMsVbE5VYK5fPIqaV6UzHLp8r6cr1UWdWTBCTgFBWCCK1ADt6AOGgCDZ/AK3sFEe9HetA/tcx7NaIuZY/AH2vcPOzWlCQ==</latexit>
<latexit sha1_base64="0Pdhr03PRt6u7uFQmsGCy911yOY=">AAACFXicbVDLSgMxFM3UV62vqks3wSK0IGVGKnYjFITiskJf0JYhk2ba0MyD5I5YhvkJN/6KGxeKuBXc+Tdm2i609UDC4ZxzSe5xQsEVmOa3kVlb39jcym7ndnb39g/yh0dtFUSSshYNRCC7DlFMcJ+1gINg3VAy4jmCdZzJTep37plUPPCbMA3ZwCMjn7ucEtCSnT+v230gUXFSwte4D+wB4tkNENfrzSQpunacBpKSjtj5glk2Z8CrxFqQAlqgYee/+sOARh7zgQqiVM8yQxjERAKngiW5fqRYSOiEjFhPU594TA3i2VYJPtPKELuB1McHPFN/T8TEU2rqOTrpERirZS8V//N6EbjVQcz9MALm0/lDbiQwBDitCA+5ZBTEVBNCJdd/xXRMJKGgi8zpEqzllVdJ+6JsVcqXd5VCrbqoI4tO0CkqIgtdoRq6RQ3UQhQ9omf0it6MJ+PFeDc+5tGMsZg5Rn9gfP4AXkueTw==</latexit>
<latexit sha1_base64="s7++NogcTuVwzYAFvVpPjIhc0y4=">AAACIHicbVDLSgMxFM34rPVVdekmWIS6KTNF0Y1QFIrLCrYVOrVk0kwbmnmY3BFKmE9x46+4caGI7vRrTNtZaOuBwMk595Dc48WCK7DtL2thcWl5ZTW3ll/f2NzaLuzsNlWUSMoaNBKRvPWIYoKHrAEcBLuNJSOBJ1jLG16O/dYDk4pH4Q2MYtYJSD/kPqcEjNQtnNZKw6NzV91L0K4vCdVuzFPtAknSFLM7PbzTlRRP7rjWnRom0i0U7bI9AZ4nTkaKKEO9W/h0exFNAhYCFUSptmPH0NFEAqeCpXk3USwmdEj6rG1oSAKmOnqyYIoPjdLDfiTNCQFP1N8JTQKlRoFnJgMCAzXrjcX/vHYC/llH8zBOgIV0+pCfCAwRHreFe1wyCmJkCKGSm79iOiCmJjCd5k0JzuzK86RZKTvH5ZPr42L1Iqsjh/bRASohB52iKrpCddRAFD2iZ/SK3qwn68V6tz6mowtWltlDf2B9/wBJ3KOs</latexit>

heading: 3 LEARNING THE N -BODY POTENTIAL
text: To demonstrate the effectiveness of the LRC-layer, we consider the problem of learning the energy and force associated with a model N -body potential in the context of molecular modeling. As mentioned in Section 1, the potential evaluation often invokes expensive ab-initio calculations that one would like to bypass for efficiency reasons.
The setup of this learning problem is as follows. First, we assume access to a black-box model potential, which consists of both short- and long-range interactions. However, internal parameters of the potential are inaccessible to the training architecture and algorithm. A set of training samples are generated by the model, where each sample consists of a configuration of the points {xi} along with the potential and force. Second, we set up a deep neural network that includes (among other components) the LRC-layer for addressing the long-range interaction. This network is trained with stochastic gradient type of algorithms using the collected dataset and the trained network can be used for predicting the potential and forces for new point cloud configurations. These two components are described in the following two subsections in detail.

heading: 3.1 MODEL PROBLEM AND DATA GENERATION
text: Model We suppose that Ω = [0, L]d, and we denote the point cloud by x = {xi}Ni=1 ⊂ Ω ⊂ Rd, for d = 1, 2, or 3. We define the total energy, the local potential and the forces acting on particle j by
U = ∑
1≤i<j≤N
ψ(xi − xj), Uj(x) = ∑
i 6=j
ψ(xi − x), and Fj = −∂xUj(x)|x=xj , (2)
respectively, where the interaction kernel ψ(r) is a smooth function, besides a possible singularity at the origin and decreases as ‖r‖ → ∞.
Sampling We define a snapshot as one configuration3 of particles, x` = {x[`]j }Nj=1, together with the global energy U [`] and the forces F [`], where ` is the index representing the number in the training/testing set. We sample the configuration of particles x` randomly, with the restriction that two particles can not be closer than a predetermined value δmin in order to avoid the singularity. After an admissible configuration is computed we generate the energy and forces following Appendix B. This process is repeated until obtaining Nsample snapshots.
3For the sake of clarity, we suppose that the number of particles at each configuration is the same.

heading: 3.2 ARCHITECTURE
text: Our network architecture consists of separate descriptors for the short- interactions and long-range interactions, respectively. To capture the short-range interaction, we compute a local convolution using for each point only its neighboring points within a ball of predetermined radius. For the long-range interactions, we compute an all-to-all convolution using the LRC-layer introduced in Section 2, whose output is distributed to each particle and then fed to a sequence of subsequent layers.
Short-range descriptor For a given particle xi, and an interaction radius R, we define Ii, the interaction list of xi, as the indices j such that ‖xi−xj‖ < R, i.e., the indices of the particles that are inside a ball of radius R centered at xi. Thus for each particle xi we build the generalized coordinates si,j = xi − xj , and the short-range descriptor
Disr = ∑
j∈Ii
fθ(si,j), (3)
where fθ : Rd → Rmsr is a function represented by a neural network specified in Appendix C.1, where msr is the number of short-range features. By construction fθ(s) is smooth and it satisfies fθ(s) = 0 for ‖s‖ > R. Long-range descriptor We feed the LRC-layer with the raw point cloud represented by {xi}Ni=1 with weights {fi}Ni=1, which for simplicity can be assumed to be equal to one here, i.e., fi = 1 for i = 1, ..., N . The output of the layer is a two-dimensional tensor uk(xi) with i = 1, . . . , N and k = 1, . . . ,Kchnls. Then for each xi, its corresponding slice given by the vector [u1(xi), u2(xi), · · · , uKchnls(xi)], is fed to a function gθ : RKchnls → Rmlr , which is represented by a neural network with non-linear activation functions. Here θ is a generic set of trainable parameters and mlr is the number of long-range features. The descriptor for particle xi, which depends on all the other particles thanks to the LRC-layer, is defined by
Dilr = gθ(u1(xi), u2(xi), · · · , uKchnls(xi)) (4)
Short-range network When only the short-range interaction is present, the short-range descriptor for each particle is fed particle-wise to a fitting network Fsr : Rmsr → R. In this case Fsr(Disr) only depends on particle xi and its neighbors. Finally, the contributions from each particle are accumulated so the short-range neural network (NN) energy and forces are given by
UNNsr =
N∑
i=1
Fsr(Disr) and (F NNsr )j = −∂xjUNNsr (5)
respectively (see Fig. 2(left)). The derivatives are computed using Tensorflow (Abadi et al., 2015) directly. This network as shown by (Zhang et al., 2018b) is rotation, translation, and permutation invariant (Zaheer et al., 2017).
We point out that this architecture can be understood as a non-linear local convolution: for each particle i one applies the same function fθ to each of its neighbors. The result is then pooled into the descriptor Disr, then processed locally by Fsr (akin to a non-linear convolution with a filter of width one), and finally pooled globally into UNNsr .
Full-range network When both the short-range and long-range interactions are present, the long range descriptor and the local descriptor are combined and fed particle-wise to a fitting network F : Rmsr+mlr → R to produce the overall neural network (NN) energy and forces
UNN =
N∑
i=1
F(Disr,Dilr), and (F NN)j = −∂xjUNN (6)
respectively (see Fig. 2(right)). Following Section 2, the long-range descriptor is translation invariant by design and can be easily made rotation invariant. Furthermore, it is well known (Zaheer et al., 2017) that this construction is permutation invariant. Further details on the implementation of the network can be found in Appendix C.3. From the structures shown in Fig. 24, it is clear that we can recover the first architecture from the second, by zeroing some entries at the fitting network, and removing the LRC-layer.
4We provide more detailed schematics in Fig. 6 and Fig. 7 in Appendix C.1
Finally, let us comment on the inference complexity of the proposed network where, for simplicity we assume that O(Kchnls) = O(msr) = O(mlr) = O(1), and that the depth of the neural networks is O(1). The cost for computing UNNsr is O(N), provided that each particle has a bounded number of neighbors. The complexity for computing the forces also scales linearly in N , albeit with higher constants. The complexity of computing both UNN and associated forces5 is O(N +NFFT logNFFT).

heading: 4 NUMERICAL RESULTS
text: The loss function is the mean squared error of the forces 1Nsample ∑Nsample `=1 ∑N i=1 ∥∥F NNθ (x [`] i )−F [`] i ∥∥2, where the i-index runs on the points of each snapshot, and ` runs on the test samples. We also generate 100 snapshots of data to test the performance of network. This particular loss could lead to shift the potential energy by up to a global constant, which can be subsequently fixed by including the error of the energy in the loss (Zhang et al., 2018b). For the testing stage of we use the relative `2 error of the forces as metric, which is defined as rel := √∑ `,i ‖F [`] i − F NNθ (x [`] i )‖2/ ∑ `,i ‖F [`] i ‖2. The standard training parameters are listed in Appendix C.4.
The experiments shown in the sequel are designed to provide a fair comparison with state-of-the-art methods for localized interactions. They showcase that, by adding a single LRC-layer, one can outperform these methods significantly.
The kernels ψ used in the experiment typically exhibit two interaction lengths: ψ(·) ≡ α1ψµ1(·) + α2ψ
µ2(·), where each of ψµ1 and ψµ2 is either a simple exponential kernel or screened-Coulomb kernel (also known as the Yukawa kernel). For each of ψµ1 and ψµ2 , the superscripts denote the reciprocal of the interaction length, i.e., length scale ∼ µ−11 or ∼ µ−12 . Without loss of generality, µ1 > µ2, so that µ1 corresponds to the short-range scale and µ2 the long-range scale. We also assume that 0 ≤ α2 ≤ α1 and α1 + α2 = 1, so that the effect of the long-range interaction can be smaller in magnitude compared to that of the short-range interaction. In the special case of α2 = 0, the kernel exhibits only a single scale ∼ µ−11 . The precise definition of the kernel depends on the spatial dimension and boundary conditions, which are explained in Appendix B.
For a fixed set of kernel parameters (µ1, µ2, α1, α2), we consider two types of data: large- and small-scale data, generated in the domains Ωlr and Ωsr respectively (details to be defined in each experiment).
The Fourier multiplier within the LRC-layer is parameterized as
φ̂β,λ(k) = 4πβ
|k|2 + λ2 , (7)
where β and λ are trainable parameters. This is a simple parameterization, and a more complex model can be used as well with minimal changes to the procedure. For all experiments shown below, two kernel channels are used and as a result there are only four trainable parameters in the LRC-layer.
The numerical results aim to show namely two properties: i) the LRC-layer is able to efficiently capture LRIs, and ii) the two-scale training strategy can reduce the amount of large-scale data significantly. To demonstrate the first property, we gradually increase the interaction length of the kernel. The accuracy of the short-range network with a fixed interaction radius is supposed to decrease rapidly, while using the LRC-layer improves the accuracy significantly. To show the second property, we generate data with two interaction lengths and train the full-range network using the one- and
5See Appendix C.2 and C.3 for further details.
Table 1: Relative testing error for trained screened-Coulomb type 1D models with α1 = 1, α2 = 0, and varying µ1. Notice that µ2 can be arbitrary here given that α2 = 0.
µ1 0.5 1.0 2.0 5.0 10.0 short-range network 0.05119 0.02919 0.00597 0.00079 0.00032 full-range network 0.00828 0.00602 0.00336 0.00077 0.00054
Figure 3: (left) Testing error of the trained 1D model with respect to the number of snapshots using the one- and two-scale training strategies using data generated with the screened-Coulomb potential and parameters µ1 = 5.0, µ2 = 0.5 (right) normalized wall-time for the LRC and the direct all-to-all computation.
two-scale strategies. Finally, we also aim to demonstrate that the LRC-layer is competitive against a direct convolution in which the all-to-all computation is performed explicitly.
1D In the first set of experiments, the domain Ω = [0, 5], N = 20 and Nsample = 1000, where Nsample is the number of snapshots and N is the total number of points in each snapshot. For the kernel, we set α2 and vary µ1 to generate datasets at different interaction lengths. For each dataset we train both short-range and full-range networks using the one-scale data. The results are summarized in Table 1, where we can observe that as the characteristic interaction length increases, the accuracy of the short-range network decreases while using the full-range network can restore the accuracy. This experiment shows that local networks are often highly accurate when the interactions are localized, but the accuracy quickly deteriorates as the interaction length increases (i.e. as µ1 decreases).
For the second set of experiments we used two sets of kernel parameters: one heavily biased towards a localized interaction length, and another in which both interaction lengths are equally weighted. For each set of kernel parameters, we generate 10, 000 small-scale snapshots using Ωsr = [0, 5] and N = 20, and a large number of large-scale snapshots using Ωlr = [0, 50] and N = 200 particles. The interaction radius R = 1.5, δmin = 0.05, and NFFT is 501. We train the network with the oneand two-scale training strategies described in the prequel. Fig. 3 (left) depicts the advantage of using the two-scale training strategy: we obtain roughly the same accuracy at a fraction of the number of large-scale training samples. We observe that when the number of large-scale training samples is sufficiently large, the resulting test accuracy is independent of the training strategy. We also observe that the training dynamics is stable with respect to different random seeds.
We compare the LRC-layer with a direct all-to-all computation.We benchmark the wall time of both layers, with increasingly number of particles. To account for implementation effects we normalize the wall times in Fig. 3 (right) and the results corroborate the complexity claims made in Section 2.
2D We perform the same experiments as in the one-dimensional case. We fix Ω = [0, 15]2, N = 450 and Nsample = 10000. The results are summarized in Table 2, which shows that as µ decreases, the full-range network outperforms the short-range one.
For the second set of experiments, R = 1.5, δmin = 0.05, and NFFT is 312. For the small-scale data, Ωsr = [0, 3]2, N = 18, and Nsample = 10, 000. For the large-scale data, Ωlr = [0, 15]2 , N = 450. Similarly to the 1D case, we train the networks with both strategies using different amounts of large-scale data. The results summarized in Fig. 4 show that the two-scale strategy efficiently captures the long-range interactions with only a small number of the long-range training samples.
Table 2: Relative testing error for trained screened-Coulomb type 2D models with α1 = 1, α2 = 0, and varying µ1. Again µ2 can be arbitrary given that α2 = 0.
µ1 1.0 2.0 5.0 10.0 short-range network 0.07847 0.02332 0.00433 0.00242 full-range network 0.00785 0.00526 0.00363 0.00181
Figure 4: Testing error of the trained 2D model with respect to the number of snapshots using the one- and two-scale training strategies using both screened-Coulomb and exponential potentials with µ1 = 10, µ2 = 1 : (left) α1 = 0.9, and α2 = 0.1; and (right) α1 = 0.5, and α2 = 0.5.
Analogously to the 1D case, we can observe that for sufficiently large-scale training samples the resulting test accuracy is identical regardless of the training strategy used. Also similar to Fig. 3 (left), we find that the lowest achievable test error is larger in Fig. 4 (right, with a larger α2) than that in Fig. 4 (left, with a smaller α2). Nonetheless, we observe that the test error of the two-scale training strategy becomes less sensitive with respect to the number of training samples when α2 becomes larger, i.e. the LRI becomes more prominent.
3D The domain Ω is [0, 3]3 with 2 points in each of the 27 unit cells. The other parameters are the interaction radius R = 1.0, δmin = 0.1, and Nsample = 1000. The Fourier domain used is of size NFFT = 25
3. The results in Table 3 demonstrate that full-range network is capable of maintaining good accuracy for a wide range of characteristic interactions lengths.

heading: 5 CONCLUSION
text: We have presented an efficient long-range convolutional (LRC) layer, which leverages the nonuniform fast Fourier transform (NUFFT) to reduce the cost from quadratic to nearly-linear with respect to the number of degrees of freedom. We have also introduced a two-scale training strategy to effectively reduce the number of large-scale samples. This can be particularly important when the generation of these large-scale samples dominates the computational cost. While this paper demonstrates the effectiveness of the LRC-layer for computing the energy and force associated with a model N -body potential, we expect the LRC-layer to become a useful component in designing neural networks for modeling real chemical and materials systems, where the LRI cannot be accurately captured using short ranged models. We also expect that the LRC-layer can be a useful tool for a wide range of machine learning (such as regression and classification) tasks.

heading: A NOTATION
text: A table of notations is summarized in Table 4.

heading: B DATA GENERATION
text: We provide further details about the data generation process and how the parameter µ dictates the characteristic interaction length.
Exponential kernel: Suppose Ω be the torus [0, L]d and that x = {xi}Ni=1 ⊂ Ω ⊂ Rd for d = 1, 2, or 3. The exponential kernel is defined as
ψµ(x− y) = e−µ‖x−y‖, (8) where ‖ · ‖ is the Euclidean norm over the torus. Following Section 3.1 we define the total energy and the potential as
U =
N∑
i<j
e−µ‖xi−xj‖ and Uj(x) = N∑
i6=j
e−µ‖xi−x‖, (9)
respectively. The forces are given by
Fj = −∂xjUj(xj) = − N∑
i 6=j
xi − xj ‖xi − xj‖ µe−µ‖xi−xj‖. (10)
Screened-Coulomb kernel: In 3D, the screened-Coulomb potential with free space boundary condition is given by
ψµ(x− y) = 1 4π‖x− y‖e −µ‖x−y‖. (11)
Over the torus [0, L]d, the kernel ψµ(x− y) is the Green’s function Gµ(x, y) defined via ∆Gµ(x, y)− µ2Gµ(x, y) = −δy(x), (12)
with the periodic boundary condition. In order to compute the screened-Coulomb potential numerically, a spectral method is used: in particular,
ψµ(x− y) = Gµ(x, y) = F−1 ( eik·y ‖k‖2 + µ2χ (k) ) , (13)
where F−1 stands for the inverse Fourier transform and χ (k) is a smoothing factor, usually Gaussian, to numerically avoid the Gibbs phenomenon. Similar to the exponential case, the parameter µ controls the localization of the potential. In addition, the derivatives are taken numerically in the Fourier domain.
Visualization: To visualize the relation between µ and the characteristic interaction length in 1D, consider a given particle, e.g., x100 and compute the force contribution from the other particles. Fig. 5 shows that force contribution is extremely small outside a small interaction region for µ = 5.0 while the interaction region for µ = 0.5 is much larger.

heading: C DETAILS OF ARCHITECTURE AND TRAINING
text: C.1 SHORT-RANGE DESCRIPTOR
Here we specify the structure of Di introduced in Section 3.2. For a given particle xi, and an interaction radiusR, define the interaction list Ii of xi as the set of indices j such that ‖xi−xj‖ < R, where ‖ · ‖ stands for the distance over the torus [0, L]d. To simplify the discussion, we assume that there exists a maximal number of neighbors NmaxNeigh for each xi. We stack the neighbors in a tensor whose dimensions are constant across different particles. This value is chosen to be sufficiently
large to cover the number of elements in the interaction list. If the cardinality of Ii is less than NmaxNeigh, we pad the tensor with dummy values.
In the 1D case the generalized coordinates are defined as
si,j = ‖xi − xj‖, and ri,j = 1
‖xi − xj‖ (14)
for j ∈ Ii. We introduce two fully-connected neural networks fθ1 , fθ2 : R+ → Rmsr/2, where each consists of five layers with the number of units doubling at each layer and ranging from 2 to 32. The activation function after each layer is tanh and the initialization follows Glorot normal distribution.
For particle xi the short-range descriptor is defined as the concatenation of
Di1,sr = ∑
j∈Ii
fθ1(ŝi,j)r̂i,j and Di2,sr = ∑
j∈Ii
fθ2(r̂i,j)r̂i,j , (15)
where r̂i,j , ŝi,j are the normalized copies of ri,j and si,j with mean zero and standard deviation equals to one. The mean and standard deviation are estimated by using a small number of snapshots. We multiply the network’s output fθ by r̂i,j (which is zero if j is a dummy particle). This procedure enforces a zero output for particles not in the interaction list. The construction satisfies the design requirement mentioned in Section 3.2.
In the short-range network, one concatenates the two descriptor above and feeds them particle-wise to the short-range fitting network. The fitting network Fsr : Rmsr → R is a residual neural network (ResNet) with six layers, each with 32 units. The activation function and initialization strategy are the same as the ones for the short-range descriptors. Fig. 6 shows the detailed architecture of the short-range network.
UNNsr =
N∑
i=1
F(Disr) = N∑
i=1
F(Di1,sr,Di2,sr) (16)
In 2D and 3D, there is a slight difference of generalized coordinates: we compute
si,j = xi − xj ‖xi − xj‖
and ri,j = 1
‖xi − xj‖ , (17)
where si,j is a vector now. The local descriptors are defined in the following forms:
Di1,sr = ∑
j∈Ii
fθ1(si,j)r̂i,j and Di2,sr = ∑
j∈Ii
fθ2(r̂i,j)r̂i,j (18)
C.2 NUFFT
In this section we provide further details for the NUFFT implementation. Suppose that the input of the NUFFT is given by {xi}Ni=1 ⊂ Rd, where each point has a given associated weight fi. The first
step is to construct the weighted train of Dirac deltas as
f(x) =
N∑
j=1
fjδ (x− xj) . (19)
We point out that in some of the experiments fj simply equals to 1. One then defines a periodic Gaussian convolution kernel
gτ (x) = ∑
`∈Zd e−‖x−`L‖ 2/4τ , (20)
where L is the length of the interval and τ determines the size of mollification. In practice a good choice is τ = 12( L2πLFFT )
2 (Dutt & Rokhlin, 1993), where LFFT is the number of points in each dimension and NFFT = LdFFT. We define
fτ (x) = f ∗ gτ (x) = ∫
[0,L]d f(y)gτ (x− y)dy =
N∑
j=1
fjgτ (x− xj). (21)
With the Fourier transform defined as
Fτ (k) = 1
Ld
∫
[0,L]d fτ (x)e
−i2πk·x/Ldx (22)
for k ∈ Zd, we compute its discrete counterpart
Fτ (k) ≈ 1
NFFT
∑
m∈[0,LFFT−1]d fτ (Lm/LFFT) e
−i2πk·m/LFFT (23)
≈ 1 NFFT
∑
m∈[0,LFFT−1]d
N∑
j=1
fjgτ (Lm/LFFT − xj) e−i2πk·m/LFFT (24)
This operation can be done in O(NFFT log(NFFT)) steps, independently of the number of inputs. Once this is computed, one can compute the Fourier transform of f at each frequency point by
F (k) = (π τ )d/2 e‖k‖ 2τFτ (k) (25)
Once the Fourier transform of the Dirac delta train is ready, we multiply it by the Fourier multiplier φ̂(k), which is the Fourier transform of φ:
v̂(k) = φ̂(k)F (k) (26)
In the next sage, one needs to compute the inverse transform, and evaluate into the target points {xi}. First we deconvolve the signal
v̂−τ (k) = (π τ )d/2 e‖k‖ 2τ v̂(k) (27)
and compute the inverse Fourier transform
u−τ (x) = ∑
k∈[0,NFFT−1]d v̂−τ (k)e
ik·x. (28)
Next, we interpolate to the point cloud
u (xj) = u−τ ∗ gτ (xj) = 1
Ld
∫
[0,L]d u−τ (x)gτ (xj − x) dx (29)
≈ 1 NFFT
∑
m∈[0,LFFT−1]d u−τ (Lm/LFFT) gτ (xj − Lm/LFFT) (30)
Even though in the current implementation all the parameters of the NUFFT are fixed, they can in principle be trained along with the rest of the networks. This training, if done naively increases significantly the computational cost. How to perform this operation efficiently is a direction of future research.
Derivatives For the computation of the forces in equation 5 one needs to compute the derivatives of the total energy UNN with respect to the inputs, in nearly-linear time. The main obstacle is how to compute the derivatives of the LRC-layer with respect to the point-cloud efficiently. To simplify the notation, we only discuss the case that d = 1, but the argument can be seamlessly extended to the case when d > 1. Recall that ui = ∑N j=1 φθ(xi − xj)fj , then the Jacobian of the vector u with respect to the inputs is given by
(∇u)i,j := ∂ui ∂xj = { −fjφ′θ(xi − xj), if j 6= i,∑ k 6=i fkφ ′ θ(xi − xk), if j = i. (31)
As it will be explained in the sequel, for the computation of the forces in equation 5 one needs to compute the application of the Jacobian of u to a vector. For a fixed vector v ∈ RN , the product (∇u) · v can be written component-wise as
((∇u) · v)i =− ∑
j 6=i
vjfjφ ′ θ(xi − xj) + vi
∑
j 6=i
fjφ ′ θ(xi − xj),
=− N∑
j=1
vjfjφ ′ θ(xi − xj) + vi
N∑
j=1
fjφ ′ θ(xi − xj),
where we have added ±vifiφ′(0) in the last equation and then distributed it within both sums. Let us define the following two long-range convolutions
wi = − N∑
j=1
vjfjφ ′ θ(xi − xj), and pi =
N∑
j=1
fjφ ′ θ(xi − xj), (32)
each of which can be performed in O(N + NFFT logNFFT) steps using the NUFFT algorithm combined with the convolution theorem. In this case the derivative of φ can be computed numerically in the Fourier domain to a very high accuracy. Now one can leverage the expression above to rewrite (∇u) · v as ((∇u) · v)i = wi + vipi, (33) which can then be computed in nearly-linear time. The same is also true for v · (∇u).
C.3 LONG-RANGE DESCRIPTOR
As mentioned before, the output of the LRC-layer is given by {u(xi)}Ni=1. For each particle we feed the output u(xi) to the long-range descriptor network hθ : R→ Rmlr , whose structure is the same
as the local descriptor fθ mentioned in appendix C.1 except that the activation function is taken to be ReLU. The long-range descriptor, defined as
Dilr = gθ(u(xi)) (34) for the particle xi is concatenated with the corresponding short-range descriptor (which it is itself the concatenation of two short-range descriptors) and fed together to the total fitting network F : Rmsr+mlr → R. The results are then added together to obtain the total energy
UNN =
N∑
i=1
F(Disr,Dilr). (35)
It is clear that the energy can be evaluated in nearly-linear complexity.
In what follows we show that the force computation is also of nearly-linear. For simplicity we focus on the one-dimensional network and assume that Kchnls = 1, O(msr) = O(mlr) = O(1) and that the depth of the neural networks is O(1). As defined in the prequel the forces are given by F NN = −∇xUNN, Which can be written component wise as
F NNj = −∂xjUNN = − N∑
i=1
[ ∂1F(Disr,Dilr)∂xjDisr + ∂2F(Disr,Dilr)g′θ(ui)∂xjui ] , (36)
or in a more compact fashion as
F NN = −∇UNN = − (vsr ·Dsr + vlr · ∇u) . (37) Here vsr, and vlr are vectors defined component-wise as (vsr)i = ∂1F(Disr,Dilr), and (vlr)i = ∂2F(Disr,Dilr)g′θ(ui). In addition (Dsr)i,j = ∂xjDisr and∇u is defined above. The first term in the right-hand side is easy to compute, given that Dsr is sparse: the i, j entry is non-zero only if the particle xi is in the interaction list of xj . Given that the cardinality of the interaction list is bounded, Dsr has O(N) non-zero entries in which each entry requires O(1) work, thus the first term in the right-hand side of equation 37 can be computed in O(N). At first glance the complexity of second term seems to be much higher. However, as discussed above, by using equation 33, we can apply the matrix (or its transpose) to a vector in O(N +NFFT logNFFT) time and the computation of vector vlr requires O(1) work per entry, thus resulting in a complexity of O(N + NFFT logNFFT) for computing the second term in equation 37. Finally, adding both contributions together results in an overall O(N +NFFT logNFFT) complexity for the forces. To summarize, both the computation of the energy and the forces can be performed in O(N) time.
C.4 TRAINING
We use the Adam optimizer (Kingma & Ba, 2015) along with an exponential scheduler. The learning rate with the initial learning rate taken to be 0.001 and, for every 10 epochs, it decreases by a factor of 0.95. In order to balance the computational time and the accuracy, a multi-stage training is adopted, where at each stage we modify the batch-size and the number of epochs. In particular, four stages are used: we start using a batch size of 8 snapshots and train the network 200 epochs and then at each stage we double both the size of the batch size and the number of epochs. In the two-scale training strategy, the same training parameters defined above are used for each stage.
C.5 DEPENDENCY ON NFFT
We measure the impact of NFFT on the approximation error, using a couple of examples in the oneand two-dimensional settings.
For the one-dimensional case, we test a screened-Coulomb type potential with parameters µ1 = 5.0, µ2 = 0.5, α1 = 0.5, α2 = 0.5, and Nsample = 1000. The domain Ω is [0, 50] and N = 200. We run the one-scale training procedure with varying NFFT (the number of Fourier multipliers), starting from NFFT = 63 and doubling them until NFFT = 501. Table 5 shows that the errors are relatively insensitive to the value of NFFT. The accuracy achieved by the architecture without the LRC-layer (denoted as None in Tables 5) is added in order to demonstrate that the architecture is indeed capturing the LRIs.
For the two-dimensional case, a screened-Coulomb type potential is tested with µ1 = 10.0, µ2 = 1.0, α1 = 0.9, α2 = 0.1. Here Ω = [0, 5]2, N = 50 and Nsample = 1000. Starting with NFFT = 212, we steadily increase its value and repeat the same training procedure. The results are summarized in Table 6 where one observes the same trend as in the one-dimensional case.
In addition, we recall that the Fourier multipliers are parametrized following
φ̂β,λ(k) = 4πβ
‖k‖2 + λ2 , (38)
where β and λ are two trainable parameters with λ providing a measure of the decay in space. Therefore, NFFT only determines the number of Fourier modes and not the parameters of the ansatz. As long as the Fourier kernel is properly sampled, the method is able to compute the correct characteristic interaction length.
One can observe this phenomenon in the experiment above, in which we extract the terminal value after training of the parameters λ1 and λ2 that correspond to the two channels in the LRC-layer, as summarized in Table 7. We observe that the value of λ2 is very close to that of µ2, which is responsible for the LRIs even for small values of NFFT.

Review summaries:
The paper proposes an efficient long-range convolution method for point clouds by using the non-uniform Fourier transform. The long-range convolutional (LRC)-layer mollifies the point cloud to an adequately sized regular grid, computes its Fourier transform, multiplies the results by a set of trainable Fourier multipliers, computes the inverse Fourier transform, and finally interpolates the result back to the point cloud. The method is demonstrated to be effective by a N-body problem.