# Machine learning for partial differential equations Using statistical or machine learning approaches to solve PDEs, and maybe even to perform inference through them. There are many approaches to ML learning of PDEs and I will document on an ad hoc basis as I need them. No claim is made to completeness.

TODO: To avoid proliferation of unclear symbols by introducing a specific example; which neural nets represent operators, which represent specific functions, between which spaces etc.

TODO: Harmonise the notation used in this section with subsections below; right now they match the papers’ notation but not each other.

TODO: should the intro section actually be filed under PDEs?

TODO: introduce a consistent notation for coordinate space, output spaces, and function space?

## Background

Suppose we have a PDE defined over some input domain, which we will presume is a time dimension and some number of spatial dimensions. The PDE is specified by some differential operator $$\mathcal{D}$$ and some forcing or boundary condition $$u\in \mathscr{U},$$ as $\mathcal{D}[f]=u.$ These functions will map from some coordinate space $$C$$ to some output space $$O$$. At the moment we consider only compact sets of positive Lebesgue measure, $$C\subseteq\mathbb{R}^{d_C}$$ and $$O\subseteq\mathbb{R}^{d_O}.$$ The first coordinate of the input space often has the special interpretation as time $$t\in \mathbb{R}$$ and the subsequent coordinates are then spatial coordinate $$x\in D\subseteq \mathbb{R}^{d_{D}}$$ where $$d_{D}=d_{C}-1.$$ Sometimes we make this explicit by writing the time coordinate separately as $$f(t,x).$$ A common case, concretely, is $$C=\mathbb{R} \times \mathbb{R}^2=\mathbb{R} \times D$$ and $$O=\mathbb{R}.$$ For each time $$t\in \mathbb{R}$$ we assume the instantaneous solution $$f(t, \cdot)$$ to be an element of some Banach space $$f\in \mathscr{A}$$ of functions $$f(t, \cdot): D\to O.$$ The overall solutions $$f: C\to O$$ have their own Banach space $$\mathscr{F}$$. More particularly, we might consider solutions a restricted time domain $$t\in [0,T]$$ and some spatial domain $$D\subseteq \mathbb{R}^2$$ where a solution is a function $$f$$ that maps $$[0,T] \times D \to \mathbb{R}.$$ This would naturally model, say, a 2D height-field evolving over time.

We have thrown the term Banach space about without making it clear which one we mean. There are usually some implied smoothness properties here and of course we would want to include some kind of metric to fully specify these spaces, but we gloss over that for now.

We have introduced one operator, the defining operator $$\mathcal{D}$$ . Another that we think about a lot is the PDE propagator or forward operator $$\mathcal{P}_s,$$ which produces a representation of the entire solution surface at some future moment, given current and boundary conditions. $\mathcal{P}_s[f(t, \cdot)]=f( t+s, \cdot).$ We might also discuss a solution operator $\mathcal{N}:\begin{array}{l}\mathscr{U}\to\mathscr{F}\\ u\mapsto f\end{array}$ such that $\mathcal{D}\left[\mathcal{N}[u]\right]=u.$

Handling all these weird, and presumably infinite-dimensional, function spaces $$\mathscr{A},\mathscr{U},\mathscr{F},\dots$$ on a finite computer requires use to introduce a notion of discretisation. We need to find some finite-dimensional representations of these functions so that they can be computed in a finite machine. PDE solvers use various tricks to do that, and each one is its own research field. Finite difference approximations treat all the solutions as values on a grid, effectively approximating $$\mathscr{F}$$ with some new space of functions $$\mathbb{Z}^2 \times \mathbb{Z} \to \mathbb{R},$$ or, if you’d like, in terms of “bar chart” basis functions. Finite element methods define the PDE over a more complicated indexing system of compactly-supported basis functions which form a mesh. Particle systems approximate PDEs with moving particle who define their own adaptive basis. If there is some other natural (preferably orthogonal) basis of functions on the solution surface we might use those, for example with the right structure the eigenfunctions of the defining operator might give us such a basis. Fourier bases are famous in this case.

A classic for neural nets is to learn a finite-difference approximation of the PDE on a grid of values and treat it as a convnet regression, and indeed the dynamical treatment of neural nets is based on that. For various practical reasons I would like to avoid requiring a grid on my input values as much as possible. For one thing, grid systems are memory intensive and need expensive GPUs. For another, it is hard to integrate observations at multiple resolutions into a gridded data system. For a third, the research field of image prediction is too crowded for easy publications. Thus, that will not be treated further here.

A grid-free approach is graph networks that learn a topology and interaction system. This seems to naturally map on to PDEs of the kind that we usually solve by particle systems, e.g. fluid dynamics with immiscible substances. Nothing wrong with this idea per se, but it does not seem to be the most compelling approach to me for my domain of spatiotemporal prediction where we already know the topology and can avoid all the complicated bits of graph networks. So this I will also ignore for now.

There are a few options here. For an overview of many other techniques see Physics-based Deep Learning by Philipp Holl, Maximilian Mueller, Patrick Schnell, Felix Trost, Nils Thuerey, Kiwon Um .

Here we look in depth mainly at two important ones.

One approach learns a network $$\hat{f}\in \mathscr{F}, \hat{f}: C \to O$$ such that $$\hat{f}\approx f$$ . This is the annoyingly-named implicit representation trick. Another approach is used in networks like Li, Kovachki, Azizzadenesheli, Liu, Bhattacharya, et al. (2020b) which learn the forward operator $$\mathcal{P}_1: \mathscr{A}\to\mathscr{A}.$$ When the papers mentioned here talk about operator learning, this is the operator that they seem to mean per default. Physics-informed approximation of dynamics

This entire idea might seem weird if you are used to typical ML research. Unlike the usual neural network setting, we start by not trying to solve a statistical inference problem, where we have to learn an unknown prediction function from data, but here we have a partially or completely known function (PDE solver) that we are trying to approximate with a more convenient substitute (a neural approximation to that PDE solver).

That approximant is, IMO not that exciting as a PDE solver in itself. Probably we could have implemented the reference PDE solver on the GPU, or tweaked it a little, and got a faster PDE solver so the speed benefit is not so useful.

However, I would like it if the reference solvers were easier to differentiate through, and to construct posteriors with - what you might call tomography, or inverse problem. Enabling advanced tomography is what I would like to do here. But note that we still do not need to use ML methods to day that. In fact, if I already know the PDE operator and am implementing it in any case, I could avoid the learning step and simply implement the PDE using an off-the-shelf differentiable solver, which would allow us to perform this inference.

Nonetheless, we might wish to learn to approximate a PDE, for whatever reason. In my case it is that am required to match an industry-standard black-box solver that is not flexible, which is a common reason. Sometimes researchers hope it might be faster to use an approximated method. YMMV.

There are several approaches to learning the dynamics of a PDE solver for given parameters.

## The PINN lineage

This body of literature encompasses both DeepONet (‘operator learning’) and PINN (‘physics informed neural nets’) approaches. Distinctions TBD.

### Deterministic PINN

NB, notation here is not yet harmonised with the notation I used in the intro. Archetypally, the PINN. Recently these have been hip . Zhang et al. (2019) credits Lagaris, Likas, and Fotiadis (1998) with originating the idea in 1998, so I suppose this is not super fresh. The key insight is that if we are elbows-deep in a neural network framework anyway, we already have access to automatic differentiation, so differential operations over the input field are basically free.

Let us introduce the basic “forward” PINN setup as given in Raissi, Perdikaris, and Karniadakis (2019): In the basic model we have the following problem $f +\mathcal{D}[f;\eta]=0, x \in \Omega, t \in[0, T]$ where $$f(t, x)$$ denotes the solution (note this $$\mathcal{D}$$ has the oppose sign to the convention we used in the intro. We assume the differential operator $$\mathcal{D}$$ is parameterised by some $$\eta$$ which for now we take to be known and suppress. Time and space axes are not treated specially in this approach but we keep them separately so that we can more closely approximate the terminology of the original paper. Our goal is to learn a neural network $$f:\mathbb{R}^e\to\mathbb{R}^{d}\in\mathscr{A}$$ that approximates the solution to this PDE. We also assume we have some observations from the true PDE solutions, presumably simulated or analytically tractable enough to be given analytically. The latter case is presumably for benchmarking, as it makes this entire approach pointless AFAICS if the analytic version is easy.

We define residual network $$r(t, x)$$ to be given by the left-hand side of the above $r:=f +\mathcal{D}[f]$ and proceed by approximating $$u(t, x;\theta)$$ with a deep neural network $$r(t, x;\theta) .$$

The approximation is data-driven, with sample set $$S_{t}$$ from a run of the PDE solver, $S=\left\{ \left\{ f( {t}_{f}^{(i)}, {x}_{f}^{(i)}) \right\}_{i=1}^{N_{f}}, \left\{ r(t_{r}^{(i)}, (x_{r}^{(i)}) \right\}_{i=1}^{N_{r}} \right\}.$

$$f(t, x;\theta)$$ and $$r(t, x;\theta)$$ share parameters $$\theta$$ (but differ in output). This seems to be a neural implicit representation-style approach, were we learn functions on coordinates. Each parameter set for the simulator to be approximated is a new dataset, and training examples are pointwise-sampled from the solution.

The key insight is that if we are elbows-deep in a neural network framework anyway, we already have access to automatic differentiation, so differential operations over the input field are basically free.

We train by minimising a combined loss, $L(\theta)=\operatorname{MSE}_{f}(\theta)+\operatorname{MSE}_{r}(\theta)$ where $\operatorname{MSE}_{f}=\frac{1}{N_{f}} \sum_{i=1}^{N_{f}}\left|f\left(t_{f}^{(i)}, x_{f}^{(i)}\right)-f^{(i)}\right|^{2}$ and $\operatorname{MSE}_{r}=\frac{1}{N_{r}} \sum_{i=1}^{N_{r}}\left|r\left(t_{r}^{(i)}, x_{r}^{(i)}\right)\right|^{2}$ Loss $$\operatorname{MSE}_{f}$$ corresponds to the initial and boundary data while $$\operatorname{MSE}_{r}$$ enforces the structure imposed by the defining differential operator at a finite set of collocation points. This trick allows us to learn an approximate solution operator which nearly enforces the desired conservation law.

An example is illustrative. Here is the reference Tensorflow interpretation from Raissi, Perdikaris, and Karniadakis (2019) for the Burger’s equation. In one space dimension, the Burger’s equation with Dirichlet boundary conditions reads $\begin{array}{l} f +f f_{x}-(0.01 / \pi) f_{x x}=0, \quad x \in[-1,1], \quad t \in[0,1] \\ f(0, x)=-\sin (\pi x) \\ f(t,-1)=f(t, 1)=0 \end{array}$ We define $$r(t, x)$$ to be given by $r:=f +f f_{x}-(0.01 / \pi) f_{x x}$

The python implementation of these two parts is essentially a naïve transcription of those equations.

def f(t, x):
f = neural_net(tf.concat([t,x],1), weights, biases)
return f

def r(t, x):
f = f(t, x)
r = f_t + f∗f_x − (0.01/ tf.pi)∗f_xx
return r

Because the outputs are parameterised by coordinates, the built-in autodiff does all the work. The authors summarise the resulting network topology so: In the terminology of Rassi’s paper $$\mathcal{N}_x,$$ corresponds to $$\mathcal{D}[f]-f,$$ and $$u$$ to $$f,$$ in the terminology of this post.

What has this gained us? So far, we have acquired a model which can, the authors assert, solve deterministic PDEs, which is nothing we could not do before. We have sacrificed any guarantee that our method will in fact do well on data from outside our observations. Also, I do not understand how I can plug alternative initial or boundary conditions in to this. There is no data input, as such, at inference time, merely coordinates. On the other hand, the author assert that this is faster and more stable than traditional solvers. It has the nice feature that the solution is continuous in its arguments; there is no grid. As far as NN things go, it has some weird and refreshing properties: it is simple, has small data, and has few tuning parameters.

But! what if we don’t know the parameters of the PDE? Assume the differential operator has parameter $$\eta$$ which is not in fact known. $f +\mathcal{D}[f;\eta]=0, x \in \Omega, t \in[0, T]$ The trick, as far as I can tell, is simply to include $$\eta$$ in trainable parameters. $r(\eta):=f (\eta)+\mathcal{D}[f;\eta]$ and proceed by approximating $$f(t, x;\theta,\eta)$$ with a deep neural network $$r(t, x;\theta,\eta) .$$ Everything else proceeds as before.

Fine; now what? Two obvious challenges from where I am sitting.

1. No way of changing inputs in the sense of initial or boundary conditions, without re-training the model
2. Point predictions. No accounting for randomness or uncertainty.

### Stochastic PINN

Zhang et al. (2019) address point 2 via chaos expansions to handle the PDE emulation as a stochastic process regression, which apparently gives us estimates of parametric and process uncertainty. All diagrams in this section come from that paper.

🏗️ Terminology warning: I have not yet harmonised the terminology of this section with the rest of the page.

The extended model adds a random noise parameter $$k(x ; \omega)$$: $\begin{array}{c} \mathcal{D}_{x}[u(x ; \omega) ; k(x ; \omega)]=0, \quad x \in \mathcal{D}, \quad \omega \in \Omega \\ \text { B.C. } \quad \mathcal{B}_{x}[u(x ; \omega)]=0, \quad x \in \Gamma \end{array}$

The randomness in this could indicate a random coupling term, or uncertainty in some parameter of the model. Think of a Gaussian process prior over the forcing term of the PDE. We sample this noise parameter also and augment the data set with it, over $$N$$ distinct realisations, giving a data set like this:

$S=\left\{ \left\{ k( {t}_u^{(i)}, {x}_u^{(i)}; \omega_{s}) \right\}_{i=1}^{N_{u}}, \left\{ u( {t}_u^{(i)}, {x}_u^{(i)}; \omega_{s}) \right\}_{i=1}^{N_{u}}, \left\{ r(t_{r}^{(i)}, (x_{r}^{(i)}) \right\}_{i=1}^{N_{r}} \right\}_{s=1}^{N}.$

Note that I have kept the time variable explicit, unlike the paper, to match the previous section, but it gets cluttered if we continue to do this, so let’s suppress $$t$$ hereafter, and make it just another axis of a multidimensional $$x$$.

So now we approximate $$k$$. Why? AFAICT that is because we are going to make a polynomial basis for $$\xi$$ which means that we will want few dimensions.

We let $$K$$ be the $$N_{k} \times N_{k}$$ covariance matrix for the sensor measurements on $$k,$$ i.e., $K_{i, j}=\operatorname{Cov}\left(k^{(i)}, k^{(j)}\right)$ We take an eigendecomposition of $$K$$. Let $$\lambda_{l}$$ and $$\phi_{l}$$ denote $$l$$-th largest eigenvalue and its associated normalized eigenvector of Then we have $K=\Phi^{T} \Lambda \Phi$ where $$\mathbf{\Phi}=\left[\phi_{1}, \phi_{2}, \ldots, \phi_{N_{k}}\right]$$ is an orthonormal matrix and $$\boldsymbol{\Lambda}=\operatorname{diag}\left(\lambda_{1}, \lambda_{2}, \ldots \lambda_{N_{k}}\right)$$ is a diagonal matrix. Let $$\boldsymbol{k}_{s}=\left[k_{s}^{(1)}, k_{s}^{(2)}, \ldots, k_{s}^{\left(N_{k}\right)}\right]^{T}$$ be the results of the $$k$$ measurements of the $$s$$-th snapshot, then $\boldsymbol{\xi}_{s}=\boldsymbol{\Phi}^{T} \sqrt{\boldsymbol{\Lambda}}^{-1} \boldsymbol{k}_{s}$ is an whitened, i.e. uncorrelated, random vector, and hence $$\boldsymbol{k}_{s}$$ can be rewritten as a reduced dimensional expansion $\boldsymbol{k}_{s} \approx \boldsymbol{k}_{0}+\sqrt{\boldsymbol{\Lambda}^{M}} \boldsymbol{\Phi}^{M} \boldsymbol{\xi}_{s}^{M}, \quad M<N_{k}$ where $$\boldsymbol{k}_0=\mathbb{E}\boldsymbol{k}.$$ We fix $$M\ll N_k$$ and suppress it herafter.

Now we have approximated away the correlated $$\omega$$ noise and in favour of this $$\xi$$ which we have finite-dimensional representations of. $k\left(x_{k}^{(i)} ; \omega_{s}\right) \approx k_{0}\left(x_{k}^{(i)}\right)+\sum_{l=1}^{M} \sqrt{\lambda_{l}} k_{l}\left(x_{k}^{(i)}\right) \xi_{s, l}, \quad M<N_{k}$ Note that this is defined only at the observation points, though.

Next is where we use the chaos expansion trick to construct an interpolant. Suppose the measure of RV $$\xi$$ is $$\rho$$. We approximate this unknown measure by its empirical measure $$\nu_{S}$$. $\rho(\boldsymbol{\xi}) \approx \nu_{S}(\boldsymbol{\xi})=\frac{1}{N} \sum_{\boldsymbol{\xi}_{s} \in S} \delta_{\xi_{s}}(\boldsymbol{\xi})$ where $$\delta_{\xi_{s}}$$ is the Dirac measure.

We construct a polynomial basis which is orthogonal with respect to the inner product associated to this measure, specifically \begin{aligned} \langle \phi, \psi\rangle &:= \int \phi(x)\psi(x)\rho(x)\mathrm{d}x\\ &\approx \int \phi(x)\psi(x)\nu_{S}(x)\mathrm{d}x \end{aligned}

OK, so we construct an orthonormal polynomial basis $$\left\{\psi_{\alpha}(\boldsymbol{\xi})\right\}_{\alpha=0}^{P}$$ via Gram-Schmidt orthogonalization process.1 With the polynomial basis $$\left\{\psi_{\alpha}(\boldsymbol{\xi})\right\}$$ we can write a function $$g(x ; \boldsymbol{\xi})$$ in the form of the aPC expansion, $g(x ; \boldsymbol{\xi})=\sum_{\alpha=0}^{P} g_{\alpha}(x) \psi_{\alpha}(\boldsymbol{\xi})$ where the each $$g_{\alpha}(x)$$ is calculated by $g_{\alpha}(x)=\frac{1}{N} \sum_{s=1}^{N} \psi_{\alpha}\left(\boldsymbol{\xi}_{s}\right) g\left(x ; \boldsymbol{\xi}_{s}\right).$

So we are going to pick $$g$$ to be some quantity of interest in our sim, and in fact, we will take it top be two separate quantities, $$u$$ and $$k$$.

Then, we can approximate $$k$$ and $$u$$ at the $$s$$-th snapshot by $\tilde{k}\left(x ; \omega_{s}\right)=\widehat{k_{0}}(x)+\sum_{i=1}^{M} \sqrt{\lambda_{i}} \widehat{k_{i}}(x) \xi_{s, i}$ and $\tilde{u}\left(x ; \omega_{s}\right)=\sum_{\alpha=0}^{P} \widehat{u_{\alpha}}(x) \psi_{\alpha}\left(\boldsymbol{\xi}_{s}\right).$

We construct two networks here,

1. the network $$\widehat{u_{\alpha}}$$, which takes the coordinate $$x$$ as the input and outputs a $$(P+1) \times 1$$ vector of the aPC modes of $$u$$ evaluated at $$x,$$ and
2. the network $$\widehat{k_{i}}$$ that takes the coordinate $$x$$ as the input and outputs a $$(M+1) \times 1$$ vector of the $$k$$ modes.

The resulting network topology is For concreteness, here is the topology for an example problem $$\mathcal{D}:=-\frac{\mathrm{d}}{\mathrm{d} x}\left(k(x ; \omega) \frac{\mathrm{d}}{\mathrm{d} x} u\right)-f$$: At inference time we take observations of $$k$$, calculate the whitened $$\xi$$, then use the chaos expansion representation to calculate the values at unobserved locations. $\mathcal{L}\left(S_{t}\right)=\operatorname{MSE}_{u}+\operatorname{MSE}_{k}+\operatorname{MSE}_{f}$ where $\begin{array}{l} \operatorname{MSE}_{u}=\frac{1}{N N_{u}} \sum_{s=1}^{N} \sum_{i=1}^{N_{u}}\left[\left(\tilde{u}\left(x_{u}^{(i)} ; \omega_{s}\right)-u\left(x_{u}^{(i)} ; \omega_{s}\right)\right)^{2}\right] \\ \operatorname{MSE}_{k}=\frac{1}{N N_{k}} \sum_{s=1}^{N} \sum_{i=1}^{N_{k}}\left[\left(\tilde{k}\left(x_{k}^{(i)} ; \omega_{s}\right)-k\left(x_{k}^{(i)} ; \omega_{s}\right)\right)^{2}\right] \end{array}$ and $\operatorname{MSE}_{f}=\frac{1}{N N_{f}} \sum_{s=1}^{N} \sum_{i=1}^{N_{f}}\left[\left(\mathcal{D}_{x}\left[\tilde{u}\left(x_{f}^{(i)} ; \omega_{s}\right) ; \tilde{k}\left(x_{f}^{(i)} ; \omega_{s}\right)\right]\right)^{2}\right]$

After all that I would describe this as a method to construct a stochastic PDE with the desired covariance structure, which is a hard thing to do. OK, all that was very complicated. Although, it was a complicated thing to do; Consider the mess this gets us into in the Karhunen Loéve expansion and spectral expansion Anyway, after all this, presuming the neural networks are perfect, we have a good estimate of the distribution of random parameters and random output of a stochastic PDE evaluated over the whole surface from partial discrete measurements.

How do we estimate the uncertainty introduce by the neural net? Dropout.

Further questions:

1. Loss scale; gradient errors may not be comparable to value errors in the loss function.
2. Network capacity: What size networks are necessary (not the ones we lear here are tiny, with only hundreds of parameters)
3. How do we generalise this to different initial conditions? Can we learn an observation-conditional PDE?
4. After all this work it looks like I still can’t do inference on this thing. How do I update a distribution over $$k$$ by this method from observations of a new PDE?
5. Notice how the parameter inference problem for $$\eta$$ vanished for the stochastic PDE? Can we learn an estimate for $$u$$, $$\eta$$ and $$k$$ simultaneously in this setting? I imagine we repeat the trick where that parameter is learned along with the $$u$$ network.

### Weak formulation

A different network topology using the implicit representation trick is explored in Zang et al. (2020) and extended to inverse problems in Bao et al. (2020), They discuss this in terms of a weak formulation of a PDE.

🏗️ Terminology warning: I have not yet harmonised the terminology of this section with the rest of the page.

We start with the example second-order elliptic2 PDE with on domain $$\Omega \subset \mathbb{R}^{d}$$ given $\mathcal{D}[u]-f:=-\sum_{i=1}^{d} \partial_{i}\left(\sum_{j=1}^{d} a_{i j} \partial_{j} u\right)+\sum_{i=1}^{d} b_{i} \partial_{i} u+c u-f=0$ where $$a_{i j}, b_{i}, c: \Omega \rightarrow \mathbb{R}$$ for $$i, j \in[d] \triangleq\{1, \ldots, d\}, f: \Omega \rightarrow \mathbb{R}$$ and $$g: \partial \Omega \rightarrow \mathbb{R}$$ are all given. We start by assuming Dirichlet boundary conditions, $$u(x)-g(x)=0,$$ although this is rapidly generalised.

By multiplying both sides by a test function $$\varphi \in H_{0}^{1}(\Omega ; \mathbb{R})$$ and integrating by parts: $\left\{\begin{array}{l}\langle\mathcal{D}[u], \varphi\rangle \triangleq \int_{\Omega}\left(\sum_{j=1}^{d} \sum_{i=1}^{d} a_{i j} \partial_{j} u \partial_{i} \varphi+\sum_{i=1}^{d} b_{i} \varphi \partial_{i} u+c u \varphi-f \varphi\right) \mathrm{d} x=0 \\ \mathcal{B}[u]=0, \quad \text { on } \partial \Omega\end{array}\right.$

The clever insight is that this inspires an adversarial problem to find the weak solutions, by considering the $$L^2$$ operator norm of $$\mathcal{D}[u](\varphi) \triangleq\langle\mathcal{D}[u], \varphi\rangle$$. Then the operator norm of $$\mathcal{D}[u]$$ is defined $\|\mathcal{D}[u]\|_{o p} \triangleq \max \left\{\langle\mathcal{D}[u], \varphi\rangle /\|\varphi\|_{2} \mid \varphi \in H_{0}^{1}, \varphi \neq 0\right\}.$ Therefore, $$u$$ is a weak solution of the PDE if and only if $$\|\mathcal{D}[u]\|_{o p}=0$$ and the boundary condition $$\mathscr{B}[u]=0$$ is satisfied on $$\delta \Omega$$. As $$\|\mathcal{D}[u]\|_{o p} \geq 0$$, we know that a weak solution $$u$$ thus solves the following two equivalent problems in observation: $\min _{u \in H^{1}}\|\mathcal{D}[u]\|_{o p}^{2} \Longleftrightarrow \min _{u \in H^{1}} \max _{\varphi \in H_{0}^{1}}|\langle\mathcal{D}[u], \varphi\rangle|^{2} /\|\varphi\|_{2}^{2}.$

Specifically the solutions $$u_{\theta}: \mathbb{R}^{d} \rightarrow \mathbb{R}$$ are realized as a deep neural network with parameter $$\theta$$ to be learned, such that $$\mathscr{S}\left[u_{\theta}\right]$$ minimizes the (estimated) operator norm. The test function $$\varphi$$, is a deep adversarial network with parameter $$\eta$$, which adversarially challenges $$u_{\theta}$$ by maximizing $$\left\langle\mathcal{D}\left[u_{\theta}\right], \varphi_{\eta}\right\rangle/\left\|\varphi_{\eta}\right\|_{2}$$ for every given $$u_{\theta}$$.

To train the deep neural network $$u_{\theta}$$ and the adversarial network $$\varphi_{\eta}$$ we construct appropriate loss functions $$u_{\theta}$$ and $$\varphi_{\eta}$$. Since logarithm function is monotone and strictly increasing, we can for convenience formulate the objective of $$u_{\theta}$$ and $$\varphi_{\eta}$$ in the interior of $$\Omega$$ as $L_{\text {int }}(\theta, \eta) \triangleq \log \left|\left\langle\mathcal{D}\left[u_{\theta}\right], \varphi_{\eta}\right\rangle\right|^{2}-\log \left\|\varphi_{\eta}\right\|_{2}^{2}.$ In addition, the weak solution $$u_{\theta}$$ must also satisfy the boundary condition $$\mathscr{B}[u]=0$$ on $$\delta \Omega$$ which we fill in as above, calling it $$L_{\text {bdry }}(\theta).$$ The total adversarial objective function is the weighted sum of the two objectives for which we seek for a saddle point that solves the minimax problem: $\min _{o} \max L(\theta, \eta), \text{ where } L(\theta, \eta) \triangleq L_{\text {int }}(\theta, \eta)+\alpha L_{\text {bdry }}(\theta).$ $$\alpha$$ might seem arbitrary; apparently it is useful as a tuning parameter.

This is a very elegant idea, although the implicit representation thing is still a problem for my use cases.

## Learning a PDE forward operator Learning to solve a known PDE using a neural network was interesting but it left us somehow divorced from the inference problem of learning dynamics. Perhaps it would be nice to learn an operator that projects estimates of current states forward, by learning to approximate the series of solver steps that a PDE solver would. This clearly rhymes with the idea of implicit neural networks.

### Fourier neural operator

Zongyi Li blogs a neat trick here: We use Fourier transforms to capture resolution-invariant and non-local behaviour in PDE forward-propagators. Essentially, we will learn to approximate $$\mathcal{P}_1: \mathscr{A}\to\mathscr{A}.$$ There is a bouquet of papers designed to leverage this . See also Anima Anandkumar’s presentation, which phrases this in terms of Green’s functions and their relationship with Fourier transforms. See also nostalgebraist who has added some interesting commentary and also fixed up a typo in this page for me (Thanks!). Yannic Kilcher’s Fourier Neural Operator for Parametric Partial Differential Equations Explained is popular but I have not watched it. Code is at zongyi-li/fourier_neural_operator.

Ok, so wht is going on here? Learning a PDE operator is naturally expressed by a layer which acts on functions, and which is indifferent to how those functions are discretized, and in particular the scale at which they are discretized. Because this is neural net land we can be a certain type of sloppy and we don’t worry overmuch about the bandwidth of the signals we approximate; We keep some conservative number of low harmonics from the Fourier transform and use a fairly arbitrary non-Fourier maps too, and conduct the whole thing in a “high” dimensional space with vague relationship to the original problem without worrying too much about what it means.

The basic concept is heuristic and the main trick is doing lots of accounting of dimensions, and being ok with an arbitrary-dimensional Fourier transform $$\mathcal{F}:(D \rightarrow \mathbb{R}^{d}) \to (D \rightarrow \mathbb{C}^{d})$$, which looks like this:

\begin{aligned} (\mathcal{F} f)_{j}(k) &=\int_{D} f_{j}(x) e^{-2 i \pi\langle x, k\rangle} \mathrm{d} x \\ \left(\mathcal{F}^{-1} f\right)_{j}(x) &=\int_{D} f_{j}(k) e^{2 i \pi\langle x, k\rangle} \mathrm{d} k \end{aligned} for each dimension $$j=1, \ldots, d$$.

We notionally use the property that convolutions become multiplications under Fourier transform, which motivates the use of use convolutions to construct our operators. Good.

Terminology warning: $$\mathscr{A},\mathscr{U}$$ are not the same as in the first section. I need to disambiguate what I mean by input space and solution space here.

Problem set up: We assume that there is a map, $$\mathcal{G}^{\dagger}$$ which arises from the solution of a PDE. Let $$D \subset \mathbb{R}^{d}$$ be a bounded, open set which is the argument set of our PDE solutions. We consider the input space $$\mathscr{A}=\mathscr{A}\left(D ; \mathbb{R}^{d_{a}}\right)$$ of $$D\to\mathbb{R}^{d_{a}}$$, and the solution space of $$\mathscr{U}=\mathscr{U}\left(D ; \mathbb{R}^{d_{u}}\right)$$ of $$D\to\mathbb{R}^{d_{u}}$$ functions. They are both Banach spaces. $$\mathcal{G}^{\dagger}: \mathscr{A} \rightarrow \mathscr{U}$$ is a map taking input functions to solutions functions which we learn from function pairs $$\left\{a_{j}, u_{j}\right\}_{j=1}^{N}$$ where $$a_{j}\in \mathscr{A}$$ and $$u_{j}=\mathcal{G}^{\dagger}(a_{j})+\epsilon_{j}$$ where $$\epsilon{j}$$ is a corrupting noise. Further, we observe these functions only at certain points $$\{x_{1},\dots,x_{n}\}\subset D.$$

We approximate $$\mathcal{G}^{\dagger}$$ by choosing good parameters $$\theta^{\dagger} \in \Theta$$ from the parameter space in some parametric family of maps $$\mathcal{G}\left(\cdot, \theta\right)$$ so that $$\mathcal{G}\left(\cdot, \theta^{\dagger}\right)=\mathcal{\mathcal{G}}_{\theta^{\dagger}} \approx \mathcal{G}^{\dagger}$$. Specifically we minimise some cost functional $$C: \mathscr{U} \times \mathscr{U} \rightarrow \mathbb{R}$$ to find $\min _{\theta \in \Theta} \mathbb{E}_{a \sim \mu}\left[C\left(\mathcal{G}(a, \theta), \mathcal{G}^{\dagger}(a)\right)\right].$

For the neural Fourier operator in particular we assume that $$\mathcal{\mathcal{G}}_{\theta}$$ has a particular iterative form, i.e. $$\mathcal{G}= Q \circ V_{T} \circ V_{T-1} \circ \ldots \circ V_{1} \circ P$$. We introduce a new space $$\mathscr{V}=\mathscr{V}\left(D ; \mathbb{R}^{d_{v}}\right)$$. $$P$$ is a map $$\mathscr{A}\to\mathscr{V}$$ and $$Q$$ is a map $$\mathscr{V}\to\mathscr{U}$$, and each $$V_{t}$$ is a map $$\mathscr{V}\to\mathscr{V}$$. Each of $$P$$ and $$Q$$ is ‘local’ in that they depend only upon pointwise evaluations of the function, e.g. for $$a\in\mathscr{A}$$, $$(Pa)(x)=p(a(x)$$ for some $$p:\mathbb{R}^{d_{a}}\to\mathbb{R}^{d_{v}}$$. Each $$v_{j}$$ is function $$\mathbb{R}^{d_{v}}$$. As a rule we are assuming $$d_{v}>d_{a}>d_{u}.$$ $$V_{t}$$ is not local. In fact, we define $(V_{t}v)(x):=\sigma\left(W v(x)+\left(\mathcal{K}(a ; \phi) v\right)(x)\right), \quad \forall x \in D$ where $$\mathcal{K}(\cdot;\phi): \mathscr{A} \rightarrow \mathcal{L}\left(\mathscr{V}, \mathscr{V}\right)$$. This map is parameterized by $$\phi \in \Theta_{\mathcal{K}}$$. $$W: \mathbb{R}^{d_{v}} \rightarrow \mathbb{R}^{d_{v}}$$ is a linear transformation, and $$\sigma: \mathbb{R} \rightarrow \mathbb{R}$$ is a local, component-wise, non-linear activation function. $$\mathcal{K}(a ; \phi)$$ is a kernel integral transformation, by which is meant $\left(\mathcal{K}(a ; \phi) v\right)(x):=\int_{D} \kappa_{\phi}(x, a(x), y, a(y)) v(y) \mathrm{d} y, \quad \forall x \in D$ where $$\kappa_{\phi}: \mathbb{R}^{2\left(d+d_{a}\right)} \rightarrow \mathbb{R}^{d_{v} \times d_{v}}$$ is some mapping parameterized by $$\phi \in \Theta_{\mathcal{K}}$$.

Anyway, it looks like this: Li’s Fourier neural operator layer.

We immediately throw out the dependence on $$a$$ in the kernel definition replacing it with $\kappa_{\phi}(x, a(x), y, a(y)) := \kappa_{R}(x-y)$ so that the integral operator becomes a convolution. This convolution can be calculated cheaply in Fourier space, which suggests we may as well define and calculate it also in Fourier space. Accordingly, the real work happens when they define the Fourier integral operator $\left(\mathcal{K}(\phi) v\right)(x)=\mathcal{F}^{-1}\left(R \cdot\left(\mathcal{F} v\right)\right)(x) \quad \forall x \in D$ where $$R$$ is the Fourier transform of a periodic function $$\kappa: D \rightarrow \mathbb{R}^{d_{v} \times d_{v}}$$ parameterized by $$\phi \in \Theta_{\mathcal{K}}$$. Checking our units here, we have that $$\left(\mathcal{F} v\right):D \to \mathbb{C}^{d_{v}}$$ and $$R (k): D \to \mathbb{C}^{d_{v} \times d_{v}}$$. In practice, since we can work with a Fourier series rather than a continuous transform, we will choose $$k\in\{0,1,2,\dots,k_{\text{max}}\}$$ and then $$R$$ can be represented by a tensor $$\mathbb{C}^{k_{\text{max}}\times d_{v}\times d_{v}}.$$ 3 Not quite sure who is right here. Caveat emptor. We can use a different $$W$$ and $$R$$ for each iteration if we want, say $$\{W_t,R_t\}_{1\leq t \leq T}$$. So, the parameters of each of these, plus those of the maps $$P,Q$$ comprise the parameters of the whole process.

Anyway, every step in this construction is differentiable in those parameters, and some of the steps can even be found rapidly using FFTs and so on, so we are done with the setup, and have an operator that can be learned from data. Is it any good? Empirically the authors report that it is fast and precise, but I have yet to try it myself.

Quibble: They use the term ‘resolution-invariant’ loosely at a few points in the paper, and it takes some work to understand the actual defensible claim here. They do not actually prove that things are resolution invariant per se. Rather, it is not even clear what that would specifically mean in this context — no attempt to prove Nyquist conditions or other sampling-theoretic properties over the spatial domain. And, AFAICT in the time domain their method is resolution-dependent in every sense. Step size is fixed.

What is clear and what I think they mean is that there is an obvious interpretation of the solution as a continuous operator, in the sense that it can be evaluated at arbitrary (spatial) points for the same computational cost as evaluating it at the training points. Thus there is a sense in which it does not depend upon the resolution of the training set, in that we don’t any resampling of the solution to evaluate the functions our operator produces at unobserved coordinates.

What does this get us? You can, in a certain sense, treat many network structures as discrete approximations to PDE operators with a certain resolution (at least, deep Resnets with ReLU activations have such an interpretation, presumably others) and then use resampling methods to evaluate them at a different resolution, which is a more laborious process that potentially gets a similar result — see the notebook on deep learning as dynamical system for examples of doing that.

Next quibble: Why Fourier transforms, instead of a different basis? Their rationale is that integral operators can be understood as continuous convolutions in the linear case, and therefore a bit like convolutions more generally. Heuristically, stacked continuous convolutions and non-linearities might well-approximate the operations of solving a nonlinear PDE. So convolutions are what we want, and Fourier transforms turn convolutions into multiplications so we can use them. It might sounds like we should use actual convolutional neural networks to solve the PDE, but that would impose a given resolution on the solution which is not what we want. For me, a better rationale is that this Fourier transform puts us in a “nice” basis for PDEs because Fourier transforms have well-understood interpretations which encode derivatives, translations, interpolations and other useful operations, which is why we use them in classic PDE solvers. The convolution thing is more “deep net-like” though.

Also Fourier transforms are notionally fast, which is another popular deep net rationale. Implementation detail: the authors do not make any particular effort to be maximally fast by using dilation to truncate the Fourier series. Instead they calculate the whole Fourier transform then throw some bits out. Presumably because they were already fast enough without bothering with being clever.

OTOH Fourier series also encode some troubling assumptions. Essentially these amount to an assumption that the basis functions are periodic, which in turn amounts to assuming that the domain of functions is toroidal, or, I suppose, a box with uniform boundary conditions. This is pretty common, but also annoying. Li, Kovachki, Azizzadenesheli, Liu, Bhattacharya, et al. (2020b) argue that does not matter because the edge effects can be more-or-less ignored and that things will still work OK because of the “local linear projection” part, which is … fine I guess? Maybe true. It still grates. Certainly the boundary conditions situation will just be messy AFAICT for any neural operator so I am at ease with the idea they would like to simply ignore it for now.

Would alternative bases fix that boundary problem, or just be more of an annoying PITA? Would there be anything to gain from learning a basis for the expansion? Certainly you would lose speed.

Also, this method uses a lot of the right buzzwords to sound like a kernel trick approach, and one can’t help but feel there might be a logical Gaussian process regression formulation with nice Bayesian interpretation. But I can’t see an obvious way of making that fly; the operator passes though a lot of nonlinear functions and thus the pushforward measure will get gnarly, not to mention the correlation kernel. I suppose it could possibly be approximated as ‘just’ another deep Gaussian process with some tactical assumptions, perhaps infinite-width asymptotics. Laplace approximation? Or a variational approximation? But what is a plausible variational family here?

Update: See Kovachki, Lanthaler, and Mishra (2021) for some analysis of the performance of this method. TBD: read that mammoth paper.

### DeepONet

From the people who brought you PINN, above, comes the paper of Lu, Jin, and Karniadakis (2020). The setup is related, but AFAICT differs in a few ways in that

1. we don’t (necessarily?) use the derivative information at the sensor locations
2. we learn an operator mapping initial/latent conditions to output functions
3. we decompose the input function space into a basis and them sample randomly from the bases in order to span (in some sense) the input space at training time

The authors argue they have found a good topology for a network that does this

A DeepONet consists of two sub-networks, one for encoding the input function at a fixed number of sensors $$x_i, i = 1, \dots, m$$ (branch net), and another for encoding the locations for the output functions (trunk net).

This addresses some problems with generalisation that make the PINN setup seem unsatisfactory; in particular we can change the inputs, or project arbitrary inputs forward.

The boundary conditions and input points appear to stay fixed though, and inference of the unknowns is still vexed.

🏗️

## GAN approaches

One approach I am less familiar with advocates for conditional GAN models to simulate conditional latent distributions. I’m curious about these but they look more computationally expensive and specific than I need at the moment, so I’m filing for later .

A recent examples from fluid-flow dynamics has particularly beautiful animations attached:

F. Sigrist, Künsch, and Stahel (2015b) finds a nice spectral representation of certain classes of stochastic PDE. These are extended in Liu, Yeo, and Lu (2020) to non-stationary operators. By being less generic, these come out with computationally convenient spectral representations.

## Boundary conditions

Are hard to handle in a neural network context. Solutions seem diverse. Liu, Yeo, and Lu (2020) just assumes that there are some initial conditions and boundaries can be “handled” by hoping that simulating a toroidal domain then cutting out a segment of interest.

## Inverse problems

Tomography through PDEs.

Suppose I have a PDE, possibly with some unknown parameters in the driving equation. All being equal I can do not too badly at approximating that with tools already mentioned. What if I wish simultaneously infer some unknown inputs? Then we consider it as an inverse problem. This is not quite the same as the predictive problem that many of the methods here consider. However, we are free to use simulation-based inference to solve here, or MCMC methods to do so for any of the forward-operator-learning approaches. To specifically target the inverse problem directly, we might consider GANs or variational inference. At this point we are more or less required to start thinking about this in a probabilistic network or we will miss essential uncertainty quantification.

For examples of how this might work Liu, Yeo, and Lu (2020) is one approach, generalizing the approach of F. Sigrist, Künsch, and Stahel (2015b) to a system with noise. More generic methods include Bao et al. (2020); Jo et al. (2019); Lu, Mao, and Meng (2019); Raissi, Perdikaris, and Karniadakis (2019); Tait and Damoulas (2020); Xu and Darve (2020); Yang, Zhang, and Karniadakis (2020); Zhang, Guo, and Karniadakis (2020); Zhang et al. (2019).

## Differentiable solvers

Suppose we are keen to devise yet another method that will do clever things to augment PDE solvers with ML somehow. To that end it would be nice to have a PDE solver that was not a completely black box but which we could interrogate for useful gradients. Obviously all PDE solvers use gradient information, but only some of them expose that to us as users; e.g. MODFLOW will give me a solution filed but not the gradients of the field that were used to calculate that gradient. It will definitely not give me tha adjoints so that I can calculate the gradients of an objective function of that field with respect to input parameters. In ML toolkits accessing this information is easy.

OTOH, there is a lot of sophisticatd work done by PDE solvers that is hard for ML toolkits to recreate. That is why PDE solvers are a thing.

Tools which combine both worlds, PDE solutions and ML optimisations, do exist; there are adjoint method systems for mainstream PDE solvers just as there are PDE solvers for ML frameworks. Let us list some of the options here: ### Mantaflow/Phiflow

mantaflow is an open-source framework targeted at fluid simulation research in Computer Graphics and Machine Learning. Its parallelized C++ solver core, python scene definition interface and plugin system allow for quickly prototyping and testing new algorithms. A wide range of Navier-Stokes solver variants are included. It’s very versatile, and allows coupling and import/export with deep learning frameworks (e.g., tensorflow via numpy) or standalone compilation as matlab plugin. Mantaflow also serves as the simulation engine in Blender.

Feature list:

The framework can be used with or without GUI on Linux, MacOS and Windows. Here is an incomplete list of features implemented so far:

• Eulerian simulation using MAC Grids, PCG pressure solver and MacCormack advection
• Flexible particle systems
• FLIP simulations for liquids
• Surface mesh tracking
• Free surface simulations with levelsets, fast marching
• Wavelet and surface turbulence
• K-epsilon turbulence modeling and synthesis
• Maya and Blender export for rendering

Mantaflow’s particular selling point is producing stunning 3d animations as an output.

Mantaflow pairs well with tum-pbs/PhiFlow: A differentiable PDE solving framework for machine learning:

• Variety of built-in PDE operations with focus on fluid phenomena, allowing for concise formulation of simulations.
• Tight integration with PyTorch, Jax and TensorFlow for straightforward neural network training with fully differentiable simulations that can run on the GPU.
• Flexible, easy-to-use web interface featuring live visualizations and interactive controls that can affect simulations or network training on the fly.
• Object-oriented, vectorized design for expressive code, ease of use, flexibility and extensibility.
• Reusable simulation code, independent of backend and dimensionality, i.e. the exact same code can run a 2D fluid sim using NumPy and a 3D fluid sim on the GPU using TensorFlow or PyTorch.
• High-level linear equation solver with automated sparse matrix generation.

Phiflow seems to have less elaborate PDEs built-in than Mantaflow but have deeper (?)/more flexible (?) ML integration and more active development (?). As seen in various papers from this group .

### DeepXDE

DeepXDE is the reference solver implementation for PINN and DeepONet.

Use DeepXDE if you need a deep learning library that

• solves forward and inverse partial differential equations (PDEs) via physics-informed neural network (PINN),
• solves forward and inverse integro-differential equations (IDEs) via PINN,
• solves forward and inverse fractional partial differential equations (fPDEs) via fractional PINN (fPINN),
• approximates functions from multi-fidelity data via multi-fidelity NN (MFNN),
• approximates nonlinear operators via deep operator network (DeepONet),
• approximates functions from a dataset with/without constraints.

You might need to moderate your expectations a little. I did, after that bold description. This is an impressive library, but as covered above, some of the types of problems that it can solve are more limited than one might hope upon reading the description. Think of it as a neural network library that handles certain PDE calculations and you will not go too far astray.

### JuliaFEM

Julaifem is an umbrella organisation supporting julia-backed FEM solvers. The documentation is tricksy, but check out the examples, Supported solvers listed here. I assume these are all differentiable since that is a selling point of the SciML.jl ecosystem they spring from.

ADCME is suitable for conducting inverse modeling in scientific computing; specifically, ADCME targets physics informed machine learning, which leverages machine learning techniques to solve challenging scientific computing problems. The purpose of the package is to:

1. provide differentiable programming framework for scientific computing based on TensorFlow automatic differentiation (AD) backend;
2. adapt syntax to facilitate implementing scientific computing, particularly for numerical PDE discretization schemes;
3. supply missing functionalities in the backend (TensorFlow) that are important for engineering, such as sparse linear algebra, constrained optimization, etc.

Applications include

• physics informed machine learning (a.k.a., scientific machine learning, physics informed learning, etc.)
• coupled hydrological and full waveform inversion
• constitutive modeling in solid mechanics
• learning hidden geophysical dynamics
• parameter estimation in stochastic processes

The package inherits the scalability and efficiency from the well-optimized backend TensorFlow. Meanwhile, it provides access to incorporate existing C/C++ codes via the custom operators. For example, some functionalities for sparse matrices are implemented in this way and serve as extendable “plugins” for ADCME. ### FEniCS

Also seems to be a friendly PDE solver, lacking in GPU support. However, it does have an interface to pytorch, barkm/torch-fenics on the CPU to provide differentiability with respect to parameters.

The dolfin-adjoint project automatically derives the discrete adjoint and tangent linear models from a forward model written in the Python interface to FEniCS and Firedrake

These adjoint and tangent linear models are key ingredients in many important algorithms, such as data assimilation, optimal control, sensitivity analysis, design optimisation, and error estimation. Such models have made an enormous impact in fields such as meteorology and oceanography, but their use in other scientific fields has been hampered by the great practical difficulty of their derivation and implementation. In his recent book, Naumann (2011) states that

[T]he automatic generation of optimal (in terms of robustness and efficiency) adjoint versions of large-scale simulation code is one of the great open challenges in the field of High-Performance Scientific Computing.

The dolfin-adjoint project aims to solve this problem for the case where the model is implemented in the Python interface to FEniCS/Firedrake.

This provides the AD backend to torch-fenics.

### TenFEM

TenFEM offers a small selection of differentiable FEM solvers fpr Tensorflow.

### Trixi

Trixi.jl

Trixi.jl is a numerical simulation framework for hyperbolic conservation laws written in Julia. A key objective for the framework is to be useful to both scientists and students. Therefore, next to having an extensible design with a fast implementation, Trixi is focused on being easy to use for new or inexperienced users, including the installation and postprocessing procedures.

### taichi

“Sparse simulator” Tai Chi is presumably also able to solve PDEs? 🤷🏼‍♂️ If so that would be nifty because it is also differentiable. I suspect it is more of a graph network approach.

1. $$P$$, the size of the basis, depends on the highest allowed polynomial order $$r$$ in $$\psi_{\alpha}(\boldsymbol{\xi}),$$ following the formula $P+1=\frac{(r+M) !}{r ! M !}.$↩︎

2. For five internet points, can you explain to me why it must be elliptic?↩︎

3. NB — my calculations occasionally came out differing from the versions the authors gave in the paper with regards to the dimensionality of the spaces.↩︎

### 1 comment As a geophysicist working with 3D and lots of data with coupled PDEs, a fast solver is nice, but often intractably slow. Even with modern solvers. Even with GPU. Replacing the solver with a NN approximant is potentially much faster, even if the speed is merely amortized. That has so many benefits for real-world modeling work.