L EARNING N EURAL PDE S OLVERS WITH C ONVERGENCE G UARANTEES
Hsieh* Shengjia Zhao
Stephan Eismann Lucia Siemenslucia.mirabella Stefano Ermon
A BSTRACT
Partial differential equations (PDEs) are widely used across the physical and computational sciences.
Decades of research and engineering went into designing fast iterative solution methods.
Existing solvers are general purpose, but may be sub-optimal for speciﬁc classes of problems.
In contrast to existing hand-crafted solutions, we propose an approach to learn a fast iterative solver tailored to a speciﬁc domain.
We achieve this goal by learning to modify the updates of an existing solver using a deep neural network.
Crucially, our approach is proven to preserve strong correctness and convergence guarantees.
After training on a single geometry, our model generalizes to a wide variety of geometries and boundary conditions, and achieves 2-3 times speedup compared to state-of-the-art solvers.
I NTRODUCTION
Partial differential equations (PDEs) are ubiquitous tools for modeling physical phenomena, such as heat, electrostatics, and quantum mechanics.
Traditionally, PDEs are solved with hand-crafted approaches that iteratively update and improve a candidate solution until convergence.
Decades of research and engineering went into designing update rules with fast convergence properties.
The performance of existing solvers varies greatly across application domains, with no method uniformly dominating the others.
Generic solvers are typically effective, but could be far from optimal for speciﬁc domains.
In addition, high performing update rules could be too complex to design by hand.
In recent years, we have seen that for many classical problems, complex updates learned from data or experience can out-perform hand-crafted ones.
For example, for Markov chain
Monte Carlo, learned proposal distributions lead to orders of magnitude speedups compared to handdesigned ones (Song et al., 2017; Levy et al., 2017).
Other domains that beneﬁted signiﬁcantly include learned optimizers (Andrychowicz et al., 2016) and learned data structures (Kraska et al., 2018).
Our goal is to bring similar beneﬁts to PDE solvers.
Hand-designed solvers are relatively simple to analyze and are guaranteed to be correct in a large class of problems.
The main challenge is how to provide the same guarantees with a potentially much more complex learned solver.
To achieve this goal, we build our learned iterator on top of an existing standard iterative solver to inherit its desirable properties.
The iterative solver updates the solution at each step, and we learn a parameterized function to modify this update.
This function class is chosen so that for any choice of parameters, the ﬁxed point of the original iterator is preserved.
This guarantees correctness, and training can be performed to enhance convergence speed.
Because of this design, we only train on a single problem instance; our model correctly generalizes to a variety of different geometries and boundary conditions with no observable loss of performance.
As a result, our approach provides: (i) theoretical guarantees of convergence to the correct stationary solution, (ii) faster convergence than existing solvers, and (iii) generalizes to geometries and boundary conditions very different from the ones seen at training time.
This is in stark contrast with existing deep learning approaches for PDE solving (Tang et al., 2017; Farimani et al., 2017) that are limited to speciﬁc geometries and boundary conditions, and offer no guarantee of correctness.
Our approach applies to any PDE with existing linear iterative solvers.
As an example application, we solve the 2D Poisson equations.
Our method achieves a 2-3 × speedup on number of multiplyadd operations when compared to standard iterative solvers, even on domains that are signiﬁcantly different from our training set.
Moreover, compared with state-of-the-art solvers implemented in FEniCS (Logg et al., 2012), our method achieves faster performance in terms of wall clock CPU time.
Our method is also simple as opposed to deeply optimized solvers such as our baseline in FEniCS (minimal residual method + algebraic multigrid preconditioner).
Finally, since we utilize standard convolutional networks which can be easily parallelized on GPU, our approach leads to an additional 30 × speedup when run on GPU.
B ACKGROUND
In this section, we give a brief introduction of linear PDEs and iterative solvers.
We refer readers to
LeVeque (2007) for a thorough review.
2. L INEAR PDE S
Linear PDE solvers ﬁnd functions that satisfy a (possibly inﬁnite) set of linear differential equations.
More formally, let F = { (cid:117) :
R k
→ R } be the space of candidate functions, and A : F → F be a linear operator; the goal is to ﬁnd a function (cid:117) ∈ F that satisﬁes a linear equation A (cid:117) = (cid:102) , where (cid:102) is another function R k → R given by our problem.
Many PDEs fall into this framework.
For example, heat diffusion satisﬁes ∇ 2 (cid:117) =
(cid:102) (Poisson equation), where ∇ 2 = ∂ 2 ∂x 21 + · · · + ∂ 2 ∂x 2 k is the linear Laplace operator; u maps spatial coordinates (e.g. in R 3 ) into its temperature, and (cid:102) maps spatial coordinates into the heat in/out ﬂow. Solving this equation lets us know the stationary temperature given speciﬁed heat in/out ﬂow.
Usually the equation A (cid:117) =
(cid:102) does not uniquely determine (cid:117) .
For example, (cid:117) = constant for any constant is a solution to the equation ∇ 2 (cid:117) = 0 .
To ensure a unique solution we provide additional equations, called “boundary conditions”.
Several boundary conditions arise very naturally in physical problems.
A very common one is the Dirichlet boundary condition, where we pick some subset G ⊂ R k and ﬁx the values of the function on G to some ﬁxed value (cid:98) , [Equation] ) =
[Equation]
) , for all x ∈ G where the function (cid:98) is usually clear from the underlying physical problem.
As in previous literature, we refer to G as the geometry of the problem, and (cid:98) as the boundary value . We refer to the pair ( G , (cid:98) ) as the boundary condition .
In this paper, we only consider linear PDEs and boundary conditions that have unique solutions.
2. F INITE D IFFERENCE M ETHOD
Most real-world PDEs do not admit an analytic solution and must be solved numerically.
The ﬁrst step is to discretize the solution space F from R k
→ R into D k
→ R , where D is a discrete subset of R .
When the space is compact, it is discretized into an n × n × n · · · ( k many) uniform Cartesian grid with mesh width h .
Any function in F is approximated by its value on the n k grid points.
We denote the discretized function as a vector u in R n k .
In this paper, we focus on 2D problems ( k = 2 ), but the strategy applies to any dimension.
We discretize all three terms in the equation A (cid:117) =
(cid:102) and boundary condition ( G , (cid:98) ) .
The PDE solution (cid:117) is discretized such that u i,j = (cid:117)
( x i , y j ) corresponds to the value of (cid:117) at grid point ( x i , y j ) .
We can similarly discretize (cid:102) and (cid:98) .
In linear PDEs, the linear operator A is a linear combination of partial derivative operators.
For example, for the Poisson equation A = ∇ 2 = (cid:80) i ∂ 2 ∂x 2 i .
Therefore we can ﬁrst discretize each partial derivative, then linearly combine the discretized partial derivatives to obtain a discretized A .
Finite difference is a method that approximates partial derivatives in a discretized space, and as mesh width h
→ 0 , the approximation approaches the true derivative.
For example, ∂ 2 ∂x 2 (cid:117) can be discretized in 2D as ∂ 2 ∂x 2 (cid:117)
≈
h 2 ( u i − 1 ,j − 2 u i,j + u i +1 ,j ) ,
the Laplace operator in 2D can be correspondingly approximated as:
[Equation]
After discretization, we can rewrite A (cid:117) =
(cid:102) as a linear matrix equation
[Equation]
where u, f ∈ R n 2 , and A is a matrix in R n 2 × n 2 (these are n 2 dimensional because we focus on 2D problems).
In many PDEs such as the Poisson and Helmholtz equation, A is sparse, banded, and symmetric.
2. B OUNDARY C ONDITION
We also need to include the boundary condition (cid:117) ( x ) = (cid:98) ( x ) for all x ∈ G .
If a discretized point ( x i , y j ) belongs to G , we need to ﬁx the value of u i,j to b i,j .
To achieve this, we ﬁrst deﬁne e ∈ { 0 , 1 } n 2 to be a vector of 0’s and 1’s, in which 0 indicates that the corresponding point belongs to G .
Then, we deﬁne a “reset” matrix G = diag ( e ) , a diagonal matrix R n 2 → R n 2 such that
[Equation]
Intuitively G ”masks” every point in G to 0 . Similarly, I − G can mask every point not in G to 0 .
Note that the boundary values are ﬁxed and do not need to satisfy Au = f .
Thus, the solution u to the PDE under geometry G should satisfy:
[Equation]
The ﬁrst equation ensures that the interior points (points not in G ) satisfy Au = f , and the second ensures that the boundary condition is satisﬁed.
To summarize, ( A , G , (cid:102) , (cid:98) , n ) is our PDE problem , and we ﬁrst discretize the problem on an n × n grid to obtain ( A, G, f, b, n ) .
Our objective is to obtain a solution u that satisﬁes Eq.
(4), i.e. Au = f for the interior points and boundary condition u i,j = b
i,j , ∀ ( x i , y j ) ∈ G .
2. I TERATIVE S OLVERS
A linear iterative solver is deﬁned as a function that inputs the current proposed solution u ∈ R nand outputs an updated solution u (cid:48) .
Formally it is a function Ψ : R n 2 → R n 2 that can be expressed as
[Equation]
where T is a constant update matrix and c is a constant vector.
For each iterator Ψ there may be special vectors u ∗ ∈ R n 2 that satisfy u ∗ =
Ψ( u ∗ ) .
These vectors are called ﬁxed points.
The iterative solver Ψ should map any initial u 0 ∈ R n 2 to a correct solution of the PDE problem.
This is formalized in the following theorem.
Deﬁnition 1 (Valid Iterator) .
An iterator Ψ is valid w.r.t.
a PDE problem ( A, G, f, b, n ) if it satisﬁes:
a) Convergence: There is a unique ﬁxed point u ∗ such that Ψ converges to u ∗ from any initialization: ∀ u 0 ∈ R n 2 , lim k →∞ Ψ k
( u 0 )
=
u ∗ .
b) Fixed Point:
The ﬁxed point u ∗ is the solution to the linear system
Au = f under boundary condition ( G, b ) .
Convergence: Condition (a) in Deﬁnition 1 is satisﬁed if the matrix T is convergent , i.e. T k → 0 as k → ∞ .
It has been proven that T is convergent if and only if the spectral radius ρ ( T ) < 1 (Olver, 2008):
Theorem 1.
(Olver, 2008, Prop 7.25)
For a linear iterator Ψ( u )
=
Tu + c , Ψ converges to a unique stable ﬁxed point from any initialization if and only if the spectral radius ρ ( T ) < 1 .
Proof.
See Appendix A.
It is important to note that Condition (a) only depends on T and not the constant c .
Fixed Point: Condition (b) in Deﬁnition 1 contains two requirements: satisfy Au = f , and the boundary condition ( G, b ) . To satisfy Au = f a standard approach is to design Ψ by matrix splitting: split the matrix A into A
= M − N ; rewrite Au = f
as Mu = Nu + f (LeVeque, 2007).
This naturally suggests the iterative update
[Equation]
Because Eq. (6) is a rewrite of Au = f , stationary points u ∗ of Eq.
(6) satisfy Au ∗ =
f .
Clearly, the choices of M and N are arbitrary but crucial.
From Theorem 1, we must choose M such that the update converges. In addition, M − 1 must easy to compute (e.g., diagonal).
Finally we also need to satisfy the boundary condition ( I − G ) u
= ( I − G ) b in Eq.4. After each update in Eq. (6), the boundary condition could be violated. We use the “reset” operator deﬁned in
Eq. (3) to “reset” the values of u i,j to b i,j by Gu + ( I − G ) b . The ﬁnal update rule becomes
[Equation]
Despite the added complexity, it is still a linear update rule in the form of u (cid:48)
= Tu + c in Eq. (5): we have T = GM − 1 N and c = GM − 1 f + (1 − G ) b .
As long as M is a full rank diagonal matrix, ﬁxed points of this equation satisﬁes Eq. In other words, such a ﬁxed point is a solution of the PDE problem ( A, G, f, b, n ) . Proposition 1.
If M is a full rank diagonal matrix, and u ∗ ∈ R n 2 × n 2 satisﬁes Eq.
(7), then u ∗ satisﬁes Eq. 2.4. J ACOBI M ETHOD A simple but effective way to choose M is the Jacobi method, which sets M =
I (a full rank diagonal matrix, as required by Proposition 1).
For Poisson equations, this update rule has the following form,
[Equation]
For Poisson equations and any geometry G , the update matrix T =
G ( I − A ) has spectral radius ρ ( T ) <
1 (see Appendix B).
In addition, by Proposition 1 any ﬁxed point of the update rule Eq.(8,9) must satisfy Eq.
Both convergence and ﬁxed point conditions from Deﬁnition 1 are satisﬁed:
Jacobi iterator Eq.(8,9) is valid for any Poisson PDE problem.
In addition, each step of the Jacobi update can be implemented as a neural network layer, i.e., Eq.
(8) can be efﬁciently implemented by convolving u with kernel (cid:32)1 / 1 / 1 / 1 / (cid:33) and adding h 2 f/ 4 .
The “reset” step in Eq.
(9) can also be implemented as multiplying u with G and adding the boundary values (1 − G ) b .
2.4. M ULTIGRID M ETHOD
The Jacobi method has very slow convergence rate (LeVeque, 2007).
This is evident from the update rule, where the value at each grid point is only inﬂuenced by its immediate neighbors.
To propagate information from one grid point to another, we need as many iterations as their distance on the grid.
The key insight of the Multigrid method is to perform Jacobi updates on a downsampled (coarser) grid and then upsample the results.
A common structure is the V-cycle (Briggs et al., 2000).
In each
V-cycle, there are k downsampling layers followed by k upsampling layers, and multiple Jacobi updates are performed at each resolution.
The downsampling and upsampling operations are also called restriction and prolongation , and are often implemented using weighted restriction and linear interpolation respectively.
The advantage of the multigrid method is clear: on a downsampled grid (by a factor of 2) with mesh width 2 h , information propagation is twice as fast, and each iteration requires only 1/4 operations compared to the original grid with mesh width h .
L EARNING F AST AND P ROVABLY C ORRECT I TERATIVE PDE S OLVERS
A PDE problem consists of ﬁve components ( A , G , (cid:102) , (cid:98) , n ) .
One is often interested in solving the same PDE class A under varying (cid:102) , discretization n , and boundary conditions ( G , (cid:98) ) .
For example, solving the Poisson equation under different boundary conditions (e.g., corresponding to different mechanical systems governed by the same physics).
In this paper, we ﬁx A but vary G , (cid:102) , (cid:98) , n , and learn an iterator that solves a class of PDE problems governed by the same A .
For a discretized
PDE problem ( A, G, f, b, n ) and given a standard (hand designed) iterative solver Ψ , our goal is to improve upon Ψ and learn a solver Φ that has (1) correct ﬁxed point and (2) fast convergence (on average) on the class of problems of interest.
We will proceed to parameterize a family of Φ that satisﬁes (1) by design, and achieve (2) by optimization.
In practice, we can only train Φ on a small number of problems ( A, f i , G i , b i , n i ) .
To be useful, Φ must deliver good performance on every choice of G, f, b , and different grid sizes n .
We show, theoretically and empirically, that our iterator family has good generalization properties: even if we train on a single problem ( A, G, f, b, n ) , the iterator performs well on very different choices of G, f, b , and grid size n .
For example, we train our iterator on a 64 × 64 square domain, and test on a 256 × 256 L-shaped domain (see Figure 1).
3. F ORMULATION
For a ﬁxed PDE problem class A , let Ψ be a standard linear iterative solver known to be valid.
We will use more formal notation Ψ( u ; G, f, b, n ) as Ψ is a function of u , but also depends on G, f, b, n .
Our assumption is that for any choice of G, f, b, n (but ﬁxed PDE class A ), Ψ( u ; G, f, b, n ) is valid.
We previously showed that Jacobi iterator Eq.(8,9) have this property for the Poisson PDE class.
We design our new family of iterators Φ H : R n 2 → R n 2 as
[Equation]
where H is a learned linear operator (it satisﬁes H 0 = 0 ).
The term GHw can be interpreted as a correction term to Ψ( u ; G, f, b, n ) .
When there is no confusion, we neglect the dependence on G, f, b, n and denote as Ψ( u ) and Φ H ( u ) .
Φ H should have similar computation complexity as Ψ .
Therefore, we choose H to be a convolutional operator, which can be parameterized by a deep linear convolutional network.
We will discuss the parameterization of H in detail in Section 3.4; we ﬁrst prove some parameterization independent properties.
The correct PDE solution is a ﬁxed point of Φ H by the following lemma:
Lemma 1.
For any PDE problem ( A, G, f, b, n ) and choice of H , if u ∗ is a ﬁxed point of Ψ , it is a ﬁxed point of Φ H in Eq.
Proof.
Based on the iterative rule in Eq.
(10), if u ∗ satisﬁes Ψ( u ∗ ) =
u ∗ then w = Ψ
( u ∗ ) − u ∗ = 0 .
Therefore, Φ H ( u ∗ ) =
Ψ( u ∗ ) + GH 0 = u ∗ .
Moreover, the space of Φ H subsumes the standard solver Ψ .
If H = 0 , then Φ H =
Ψ .
Furthermore, denote Ψ( u ) =
Tu + c , then if H = T , then since GT =
T (see Eq.
[Equation]
[Equation]
which is equal to two iterations of Ψ .
Computing Ψ requires one convolution T , while computing Φ H requires two convolutions: T and H .
Therefore, if we choose H = T , then Φ H computes two iterations of Ψ with two convolutions: it is at least as efﬁcient as the standard solver Ψ .
3. T RAINING AND G ENERALIZATION
We train our iterator Φ H ( u ; G, f, b, n ) to converge quickly to the ground truth solution on a set
D = { ( G l , f l , b l , n l ) } Ml =1 of problem instances.
For each instance, the ground truth solution u ∗ is obtained from the existing solver Ψ .
The learning objective is then
[Equation]
Intuitively, we look for a matrix H such that the corresponding iterator Φ H will get us as close as possible to the solution in k steps, starting from a random initialization u 0 sampled from a white
Gaussian.
k in our experiments is uniformly chosen from [1 , 20] , similar to the procedure in (Song et al., 2017).
Smaller k is easier to learn with less steps to back-propagate through, while larger k better approximates our test-time setting: we care about the ﬁnal approximation accuracy after a given number of iteration steps.
Combining smaller and larger k performs best in practice.
We show in the following theorem that there is a convex open set of H that the learning algorithm can explore.
To simplify the statement of the theorem, for any linear iterator Φ( u )
=
Tu + c we will refer to the spectral radius (norm) of Φ as the spectral radius (norm) of T .
Theorem 2.
For ﬁxed G, f, b, n , the spectral norm of Φ H ( u ; G, f, b, n ) is a convex function of H , and the set of H such that the spectral norm of Φ H ( u ; G, f, b, n ) < 1 is a convex open set.
Proof.
See Appendix A.
Therefore, to ﬁnd an iterator with small spectral norm, the learning algorithm only has to explore a convex open set.
Note that Theorem 2 holds for spectral norm , whereas validity requires small spectral radius in Theorem 1.
Nonetheless, several important PDE problems (Poisson, Helmholtz, etc) are symmetric, so it is natural to use a symmetric iterator, which means that spectral norm is equal to spectral radius.
In our experiments, we do not explicitly enforce symmetry, but we observe that the optimization ﬁnds symmetric iterators automatically.
For training, we use a single grid size n , a single geometry G , f = 0 , and a restricted set of boundary conditions b .
The geometry we use is a square domain shown in Figure 1a.
Although we train on a single domain, the model has surprising generalization properties, which we show in the following:
Proposition 2.
For ﬁxed A, G, n and ﬁxed H , if for some f 0 , b 0 , Φ H ( u ; G, f 0 , b 0 , n ) is valid for the
PDE problem ( A, G, f 0 , b 0 , n ) , then for all f and b , the iterator Φ H ( u ; G, f, b, n ) is valid for the
PDE problem ( A, G, f, b, n ) .
Proof.
See Appendix A.
The proposition states that we freely generalize to different f and b .
There is no guarantee that we can generalize to different G and n .
Generalization to different G and n has to be empirically veriﬁed: in our experiments, our learned iterator converges to the correct solution for a variety of grid sizes n and geometries G , even though it was only trained on one grid size and geometry.
Even when generalization fails, there is no risk of obtaining incorrect results.
The iterator will simply fail to converge.
This is because according to Lemma 1, ﬁxed points of our new iterator is the same as the ﬁxed point of hand designed iterator Ψ .
Therefore if our iterator is convergent, it is valid.
3. I NTERPRETATION OF H
What is H trying to approximate?
In this section we show that we are training our linear function GH to approximate T ( I − T ) − 1 : if it were able to approximate T ( I − T ) − 1 perfectly, our iterator Φ H will converge to the correct solution in a single iteration.
Let the original update rule be Ψ( u ) =
Tu + c , and the unknown ground truth solution be u ∗ satisfying u ∗ =
Tu ∗ + c .
Let r = u ∗ − u be the current error, and e = u ∗ − Ψ( u ) be the new error after applying one step of Ψ .
They are related by
[Equation]
In addition, let w = Ψ( u ) − u be the update Ψ makes. This is related to the current error r by
[Equation]
From Eq. (10) we can observe that the linear operator GH takes as input Ψ ’s update w , and tries to approximate the error e : GHw ≈ e . If the approximation were perfect: GHw = e , the iterator Φ H would converge in a single iteration.
Therefore, we are trying to ﬁnd some linear operator R , such that Rw = e . In fact, if we combine Eq. (13) and Eq. (14), we can observe that T ( I − T ) − 1 is (uniquely) the linear operator we are looking for
[Equation]
where ( I − T ) − 1 exists because ρ ( T ) < 1 , so all eigenvalues of I − T must be strictly positive.
Therefore, we would like our linear function GH to approximate T ( I − T ) − 1 .
Note that ( I − T ) − 1 is a dense matrix in general, meaning that it is impossible to exactly achieve GH = T ( I − T ) − 1 with a convolutional operator H .
However, the better GH is able to approximate
T ( I − T ) − 1 , the faster our iterator converges to the solution u ∗ .
3. L INEAR D EEP N ETWORKS
In our iterator design, H is a linear function parameterized by a linear deep network without nonlinearity or bias terms.
Even though our objective in Eq.
(12) is a non-linear function of the parameters of the deep network, this is not an issue in practice.
In particular, Arora et al.
(2018) observes that when modeling linear functions, deep networks can be faster to optimize with gradient descent compared to linear ones, despite non-convexity.
Even though a linear deep network can only represent a linear function, it has several advantages.
On an n × n grid, each convolution layer only requires O ( n 2 ) computation and have a constant number of parameters, while a general linear function requires O ( n 4 ) computation and have O ( n 4 ) parameters.
Stacking d convolution layers allows us to parameterize complex linear functions with large receptive ﬁelds, while only requiring O ( dn 2 ) computation and O ( d ) parameters.
We experiment on two types of linear deep networks:
Conv model.
We model H as a network with 3 × 3 convolutional layers without non-linearity or bias.
We will refer to a model with k layers as “Conv k ”, e.g. Conv3 has 3 convolutional layers.
U-Net model.
The Conv models suffer from the same problem as Jacobi: the receptive ﬁeld grows only by 1 for each additional layer.
To resolve this problem, we design the deep network counterpart of the Multigrid method.
Instead of manually designing the sub-sampling / super-sampling functions, we use a U-Net architecture (Ronneberger et al., 2015) to learn them from data.
Because each layer reduces the grid size by half, and the i -th layer of the U-Net only operates on (2 − i n ) -sized grids, the total computation is only increased by a factor of 1 + 1 / 4 + 1 / 16 + · · · < 4 /compared to a two-layer convolution.
The minimal overhead provides a very large improvement of convergence speed in our experiments.
We will refer to Multigrid and U-Net models with k sub-sampling layers as Multigrid k and U-Net k , e.g. U-Net2 is a model with 2 sub-sampling layers.
E XPERIMENTS 4. S ETTING
We evaluate our method on the 2D Poisson equation with Dirichlet boundary conditions, ∇ 2 (cid:117) =
(cid:102) .
There exist several iterative solvers for the Poisson equation, including Jacobi, Gauss-Seidel, conjugate-gradient, and multigrid methods.
We select the Jacobi method as our standard solver Ψ .
To reemphasize, our goal is to train a model on simple domains where the ground truth solutions can be easily obtained, and then evaluate its performance on different geometries and boundary conditions.
Therefore, for training, we select the simplest Laplace equation, ∇ 2 (cid:117) = 0 , on a square domain with boundary conditions such that each side is a random ﬁxed value.
Figure 1a shows an [Figure] example of our training domain and its ground truth solution.
This setting is also used in Farimani et al.
(2017) and Sharma et al.
For testing, we use larger grid sizes than training. For example, we test on 256 × 256 grid for a model trained on 64 × 64 grids.
Moreover, we designed challenging geometries to test the generalization of our models.
We test generalization on 4 different settings: (i) same geometry but larger grid, (ii) L-shape geometry, (iii)
Cylinders geometry, and (iv) Poisson equation in same geometry, but f (cid:54) = 0 .
The two geometries are designed because the models were trained on square domains and have never seen sharp or curved boundaries.
Examples of the 4 settings are shown in Figure 1.
4. E VALUATION
As discussed in Section 2.4, the convergence rate of any linear iterator can be determined from the spectral radius ρ ( T ) , which provides guarantees on convergence and convergence rate.
However, a fair comparison should also consider the computation cost of H .
Thus, we evaluate the convergence rate by calculating the computation cost required for the error to drop below a certain threshold.
On GPU, the Jacobi iterator and our model can both be efﬁciently implemented as convolutional layers.
Thus, we measure the computation cost by the number of convolutional layers.
On CPU, each Jacobi iteration u (cid:48)
i,j = 14 ( u i − 1 ,j + u i +1 ,j + u i,j − 1 + u i,j +1 ) has 4 multiply-add operations, while a 3 × 3 convolutional kernel requires 9 operations, so we measure the computation cost by the number of multiply-add operations.
This metric is biased in favor of Jacobi because there is little practical reason to implement convolutions on CPU.
Nonetheless, we report both metrics in our experiments.
4. C ONV M ODEL
Table 1 shows results of the Conv model.
The model is trained on a 16 × 16 square domain, and tested on 64 × 64 .
For all settings, our models converge to the correct solution, and require less computation than Jacobi.
The best model, Conv3, is ∼ 5 × faster than Jacobi in terms of layers, and ∼ 2 .
5 × faster in terms of multiply-add operations.
As discussed in Section 3.2, if our iterator converges for a geometry, then it is guaranteed to converge to the correct solution for any f and boundary values b .
The experiment results show that our model not only converges but also converges faster than the standard solver, even though it is only trained on a smaller square domain.
4. U-N ET M ODEL
For the U-Net models, we compare them against Multigrid models with the same number of subsampling and smoothing layers.
Therefore, our models have the same number of convolutional layers, and roughly 9 / 4 times the number of operations compared to Multigrid.
The model is trained on a 64 × 64 square domain, and tested on 256 × 256 .
The bottom part of Table 1 shows the results of the U-Net model.
Similar to the results of Conv models, our models outperforms Multigrid in all settings.
Note that U-Net2 has lower computation [Table] [Figure] cost compared with Multigrid2 than U-Net3 compared to Multigrid 3.
This is because Multigrid2 is a relatively worse baseline. U-Net3 still converges faster than U-Net2.
4. C OMPARISON WITH FE NI CS
The FEniCS package (Logg et al., 2012) provides a collection of tools with high-level Python and
C++ interfaces to solve differential equations.
The open-source project is developed and maintained by a global community of scientists and software developers.
Its extensive optimization over the years, including the support for parallel computation, has led to its widespread adaption in industry and academia (Alnæs et al., 2015).
We measure the wall clock time of the FEniCS model and our model, run on the same hardware.
The FEniCS model is set to be the minimal residual method with algebraic multigrid preconditioner, which we measure to be the fastest compared to other methods such as Jacobi or Incomplete LU factorization preconditioner.
We ignore the time it takes to set up geometry and boundary conditions, and only consider the time the solver takes to solve the problem.
We set the error threshold to be 1 percent of the initial error.
For the square domain, we use a quadrilateral mesh.
For the L-shape and cylinder domains, however, we let FEniCS generate the mesh automatically, while ensuring the number of mesh points to be similar.
Figure 2 shows that our model is comparable or faster than FEniCS in wall clock time.
These experiments are all done on CPU.
Our model efﬁciently runs on GPU, while the fast but complex methods in FEniCS do not have efﬁcient GPU implementations available.
On GPU, we measure an additional 30 × speedup (on Tesla K80 GPU, compared with a 64-core CPU).
R ELATED W ORK
Recently, there have been several works on applying deep learning to solve the Poisson equation.
However, to the best of our knowledge, previous works used deep networks to directly generate the solution; they have no correctness guarantees and are not generalizable to arbitrary grid sizes and boundary conditions.
Most related to our work are (Farimani et al., 2017) and (Sharma et al., 2018), which learn deep networks to output the solution of the 2D Laplace equation (a special case where f = 0 ).
(Farimani et al., 2017) trained a U-Net model that takes in the boundary condition as a 2D image and outputs the solution. The model is trained by L1 loss to the ground truth solution and an adversarial discriminator loss.
(Sharma et al., 2018) also trained a U-net model but used a weakly-supervised loss.
There are other related works that solved the Poisson equation in concrete physical problems.
(Tang et al., 2017) solved for electric potential in 2D/3D space; (Tompson et al., 2017) solved for pressure ﬁelds for ﬂuid simulation; (Zhang et al., 2018) solved particle simulation of a PN Junction.
There are other works that solve other types of PDEs.
For example, many studies aimed to use deep learning to accelerate and approximate ﬂuid dynamics, governed by the Euler equation or the Navier-Stokes equations (Guo et al., 2016; Yang et al., 2016; Chu & Thuerey, 2017; Kutz, 2017).
(Eismann et al., 2018) use Bayesian optimization to design shapes with reduced drag coefﬁcients in laminar ﬂuid ﬂow.
Other applications include solving the Schrodinger equation (Mills et al., 2017), turbulence modeling (Singh et al., 2017), and the American options and Black Scholes PDE (Sirignano & Spiliopoulos, 2018).
A lot of these PDEs are nonlinear and may not have a standard linear iterative solver, which is a limitation to our current method since our model must be built on top of an existing linear solver to ensure correctness.
We consider the extension to different PDEs as future work.
C ONCLUSION
We presented a method to learn an iterative solver for PDEs that improves on an existing standard solver.
The correct solution is theoretically guaranteed to be the ﬁxed point of our iterator.
We show that our model, trained on simple domains, can generalize to different grid sizes, geometries and boundary conditions.
It converges correctly and achieves signiﬁcant speedups compared to standard solvers, including highly optimized ones implemented in FEniCS.
A P ROOFS
Theorem 1.
For a linear iterator Ψ( u )
=
Tu + c , Ψ converges to a unique stable ﬁxed point from any initialization if and only if the spectral radius ρ ( T ) < 1 .
Proof.
Suppose ρ ( T ) < 1 , then ( I − T ) − 1 must exist because all eigenvalues of I − T must be strictly positive.
Let u ∗ =
( I − T ) − 1 c ; this u ∗ is a stationary point of the iterator Ψ , i.e. u ∗ =
Tu ∗ + c .
For any initialization u 0 , let u k = Ψ k ( u 0 ) .
The error e k = u ∗ − u k satisﬁes
[Equation]
Since ρ ( T ) < 1 , we know T k → 0 as k → ∞ (LeVeque, 2007), which means the error e k → 0 .
Therefore, Ψ converges to u ∗ from any u 0 .
Now suppose ρ ( T ) ≥ 1 .
Let λ 1 be the largest absolute eigenvalue
where ρ ( T ) =
| λ 1 | ≥ 1 , and v 1 be its corresponding eigenvector.
We select initialization u
=
u ∗ + v 1 , then e 0 = v 1 .
Because | λ 1 | ≥ 1 , we have | λ k 1 | ≥ 1 , then
[Equation]
However we know that under a different initialization ˆ u 0 = u ∗ , we have ˆ e [-
 = av 1 (cid:54)-]0 = 0 ,
so T k ˆ e 0 = 0 .
Therefore the iteration cannot converge to the same ﬁxed point from different initializations u 0 and ˆ u 0 .
Proposition 1 If M is a full rank diagonal matrix, and u ∗ ∈ R n 2 × n 2 satisﬁes Eq.
(7), then u ∗ satisﬁes Eq. Proof of Proposition 1. Let u ∗ be a ﬁxed point of Eq. (7) then
[Equation] This is equivalent to [Equation] The latter equation is equivalent to GM − 1 ( Au ∗ − f ) = 0 .
If M is a full rank diagonal matrix, this implies G ( Au ∗ − f )
= 0 , which is GAu ∗ =
Gf .
Therefore, u ∗ satisﬁes Eq.(4).
Theorem 2.
For ﬁxed G, f, b, n , the spectral norm of Φ H ( u ; G, f, b, n ) is a convex function of H , and the set of H such that the spectral norm of Φ H ( u ; G, f, b, n ) < 1 is a convex open set.
Proof.
As before, denote Ψ( u )
=
Tu + c .
Observe that
[Equation]
The spectral norm (cid:107)·(cid:107) 2 is convex with respect to its argument, and ( T + GHT − GH ) is linear in H .
Thus, (cid:107) T + GHT − GH (cid:107) 2 is convex in H as well.
Thus, under the condition that (cid:107) T +
GHT − GH (cid:107) 2 < 1 , the set of H must be convex because it is a sub-level set of the convex function (cid:107) T + GHT − GH (cid:107) 2 .
To prove that it is open, observe that (cid:107)·(cid:107) 2 is a continuous function, so (cid:107) T + GHT − GH (cid:107) 2 is a continuous map from H to the spectral radius of Φ H .
If we consider the set of H such that (cid:107) T + GHT − GH (cid:107) 2 < 1 , this set is the preimage of ( − (cid:15), 1) for any (cid:15) > 0 . As ( − (cid:15), 1) is open, its preimage must be open.
Proposition 2.
For ﬁxed A, G, n and ﬁxed H , if for some f 0 , b 0 , Φ H ( u ; G, f 0 , b 0 , n ) is valid for the PDE problem ( A, G, f 0 , b 0 , n ) , then for all f and b , the iterator Φ H ( u ; G, f, b, n ) is valid for the PDE problem ( A, G, f, b, n ) .
Proof.
From Theorem 1 and Lemma 1, our iterator is valid if and only if ρ ( T + GHT − GH ) < 1 .
The iterator T + GHT − GH only depends on A, G , and is independent of the constant c in Eq.
Thus, the validity of the iterator is independent with f and b .
Thus, if the iterator is valid for some f 0 and b 0 , then it is valid for any choice of f and b .
B P ROOF OF C ONVERGENCE OF J ACOBI M ETHOD
In Section 2.4.1, we show that for Poisson equation, the update matrix T =
G ( I − A ) .
We now formally prove that ρ ( G ( I − A )) <
1 for any G .
For any matrix T , the spectral radius is bounded by the spectral norm: ρ ( T ) ≤ (cid:107) T (cid:107) 2 , and the equality holds if T is symmetric. Since ( I − A ) is a symmetric matrix, ρ ( I − A )
= (cid:107) I − A (cid:107) 2 .
It has been proven that ρ ( I − A ) < 1 (Frankel, 1950).
Moreover, (cid:107) G (cid:107) 2 = 1 .
Finally, matrix norms are sub-multiplicative, so
[Equation]
19) ρ ( T ) < 1 is true for any G .
Thus, the standard Jacobi method is valid for the Poisson equation under any geometry.