从零手写PINN：用物理信息神经网络求解偏微分方程

做物理模拟和机器学习交叉方向这几年，我最大的感受是：真正有价值的工具，往往是那种能让你在两类知识之间自由穿梭的东西。PINN（物理信息神经网络，Physics-Informed Neural Network）就是这样一个存在。它能让神经网络在拟合数据的同时，严格遵循物理方程——比如热传导、流体运动、结构形变——真正做到“给神经网络注入物理常识”。

这篇文章我想写给两类人：一类是懂点Python但一看到偏微分方程（PDE）就心里发怵的物理小白；另一类是懂物理但一直觉得神经网络只是个黑箱工具的工程师或研究者。我会把一个最小可用的PINN从零手写出来，用一维热传导方程（或泊松方程）作为贯穿全篇的算例，把里面的核心细节、训练要点、踩坑经验全部分享出来，让你不依赖任何现成框架也能理解PINN的本质，并且能把这套思路迁移到自己的问题上。

1. 先搞懂PINN在做什么：给神经网络加“物理约束”

1.1 什么是PINN，它和普通神经网络差在哪

普通神经网络做回归或者拟合，本质上是靠大量输入输出样本去逼近某个未知映射。你把一万个点的x和u(x)丢进去，网络学到的就是“在这些点上输出这些值”的插值规律。问题在于，如果样本分布不均匀、边界区域样本稀疏，网络学出来的曲线可能完全不符合物理规律，甚至会给出负浓度、负温度这种荒谬结果。

PINN的思路不一样。它在原有的数据拟合损失之外，额外引入了一个“物理残差损失”，说白了就是：让网络输出u被代进物理方程后，方程左边的计算结果尽量等于0。比如热传导方程左边是 ∂u/∂t - α∇²u，理想情况下这个式子恒等于0。PINN会让网络输出在这条约束下尽量成立，同时边界条件和初始条件也要对齐。

这样一来，即使某些区域没有数据，只要有物理方程在那里管着，网络输出就不会“跑飞”。你可以把它想象成给神经网络装了一套物理定律的“交通规则”，它可以在数据稀疏的地方按规律外推，而不是瞎猜。

1.2 PINN的核心公式：损失函数里发生了什么

PINN的损失函数一般长这样：

[ \mathcal{L} = \lambda_{PDE} \mathcal{L}{PDE} + \lambda{BC} \mathcal{L}{BC} + \lambda{IC} \mathcal{L}{IC} + \lambda{data} \mathcal{L}_{data} ]

• (\mathcal{L}_{PDE})：把网络输出代入控制方程后的残差平方和。
• (\mathcal{L}_{BC})：在边界上，网络输出与已知边界条件的差距。
• (\mathcal{L}_{IC})：瞬态问题里，在初始时刻的差距。
• (\mathcal{L}_{data})：如果有真实实验数据/观测数据，就再加一个数据拟合项。

所有微分项，比如 (\partial u/\partial t)、(\partial^2 u/\partial x^2)，都不是用有限差分去近似，而是用神经网络的自动微分（autograd）算出来的。这是PINN最巧妙的地方，也是整个方法能够落地的技术基础。自动微分能精确计算网络输出对输入的任意阶导数，而且速度很快。

1.3 为什么不能用纯数值方法替代：传统求解器的几个痛点

经典数值方法如有限元、有限体积、有限差分，在网格规整、几何简单、材料参数稳定的问题上已经很成熟了。但有几个痛点一直存在：

• 复杂几何网格划分费时费力，特别是三维问题。
• 反问题（由部分观测数据反推物理参数）传统方法处理起来麻烦，需要频繁重算正问题。
• 高维问题的网格点数随维度爆炸增长。
• 多物理场耦合时，不同场的网格需求不一致，非常难协调。

PINN的好处是网格无关、天然适合反问题、能很方便地融合不同来源的数据。它当然不是万能的，但在不少场景下确实比传统方法灵活得多。

2. 动手前的准备：Python环境与核心库

2.1 环境搭建一步到位

写PINN不需要特别复杂的依赖，我推荐直接用Miniconda管理环境，避免不同项目之间的包版本冲突。新建一个环境：

conda create -n pinn python=3.10 conda activate pinn

然后安装核心库。我用的是PyTorch，因为它的自动微分API用起来最顺手：

pip install torch --index-url https://download.pytorch.org/whl/cpu pip install matplotlib numpy

如果之后想尝试更上层的封装，可以再装DeepXDE或者PyDREAM，但第一遍我建议先别装，自己手写一遍才能真正理解PINN的机制。

2.2 自动微分：PINN背后的“引擎”

自动微分是PyTorch、TensorFlow这类深度学习框架的基础能力。它会把你的网络计算过程变成一个计算图，然后通过链式法则反着算出每个中间变量对输入的导数。

举个例子，你定义一个函数 (u = 2x^3 + \sin(x))，在PyTorch里：

import torch x = torch.tensor([0.5], requires_grad=True) u = 2 * x**3 + torch.sin(x) u.backward() print(x.grad) # 这是 du/dx 在 x=0.5 处的值

PINN要计算的是一阶导、二阶导甚至更高阶导。二阶导需要做两次反传，或者在构造计算图时保留中间梯度后再求一次：

x = torch.tensor([0.5], requires_grad=True) u = 2 * x**3 + torch.sin(x) # 一阶导 u_x = torch.autograd.grad(u, x, create_graph=True, retain_graph=True)[0] # 二阶导 u_xx = torch.autograd.grad(u_x, x, create_graph=True, retain_graph=True)[0]

这里的create_graph=True是关键，它让一阶导的计算图也被保留下来，这样才能继续对一阶导再求一次导数。第一次写PINN的时候经常会忘记这个参数，结果一算二阶导就报错，这是最常见的入门坑。

2.3 选算例：从“一维稳态热传导”开始

PINN可以解非常复杂的问题，但第一个算例一定要足够简单，让你能一眼看出网络学得对不对。我个人强烈推荐一维稳态热传导方程（泊松方程）作为入门算例：

[ -\frac{d^2 u}{dx^2} = \pi^2 \sin(\pi x), \quad x \in [0, 1] ]

边界条件：

[ u(0)=0, \quad u(1)=0 ]

这个方程的真解是 (u(x)=\sin(\pi x))，完美，是一个光滑的钟形曲线。你训练完直接把网络输出和真解画在一起，一眼就知道有没有学对。而且它可以手工推导出残差表达式，调试起来信息量很大。

3. 从零手写一个最小可用的PINN：泊松方程实操

3.1 物理问题定义与网络结构选择

我们要求解的问题是上面那个泊松方程。它的物理意义可以理解为一根两端温度固定为0的金属杆，内部有某种热源分布，最终达到稳态后的温度分布。温度分布就是我们要逼近的 (u(x))。

PINN里的神经网络本质上是一个函数逼近器，输入是坐标(x)，输出是物理量(u)。对于一维问题，网络结构的自由度很大，我实测下来推荐用3到4层全连接层、每层32到64个神经元、激活函数选Tanh。

为什么选Tanh而不是ReLU？因为PINN需要计算网络的二阶导数，ReLU在0点处不可导，一阶导数本身就是分段常数，二阶导数恒为0，根本没法用来表达物理方程的曲率信息。Tanh光滑且二阶导丰富，是目前PINN实践中最稳妥的默认选择。

网络定义如下：

import torch import torch.nn as nn class PINN(nn.Module): def __init__(self): super().__init__() self.net = nn.Sequential( nn.Linear(1, 32), nn.Tanh(), nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, 1) ) def forward(self, x): return self.net(x)

这里的输入是(x)，输出是预测的(u)。相比普通神经网络，PINN的网络结构本身没有太多特别之处，真正的核心差异在于损失函数。

3.2 核心代码：PDE残差怎么算

接下来是最关键的部分：如何把泊松方程变成损失函数。我们需要计算网络输出的二阶导数(u_{xx})，然后代入方程：

[ loss_{PDE} = \frac{1}{N} \sum_{i=1}^{N} \left( -\frac{d^2 u}{dx^2} - \pi^2 \sin(\pi x) \right)^2 ]

代码实现中，我用torch.autograd.grad来求导。为了计算二阶导，必须开启create_graph=True：

def pde_residual(model, x): x = x.requires_grad_(True) u = model(x) # 一阶导 u_x = torch.autograd.grad( u, x, grad_outputs=torch.ones_like(u), create_graph=True, retain_graph=True )[0] # 二阶导 u_xx = torch.autograd.grad( u_x, x, grad_outputs=torch.ones_like(u_x), create_graph=True, retain_graph=True )[0] # 方程残差： -u_xx - f(x) = 0 f = (torch.pi ** 2) * torch.sin(torch.pi * x) residual = -u_xx - f return residual

有人可能会问：为什么grad_outputs要传torch.ones_like(u)？因为torch.autograd.grad对非标量输出需要指定“上游梯度”。这里我们希望每个样本点上的输出都独立计算梯度，所以上游梯度全设为1，相当于对每个点的输出分别求和之后再做反向传播。

3.3 边界条件与损失组装

边界条件部分实现得更直接。我们已知(u(0)=0)、(u(1)=0)，只要把模型在这两个点上的输出和0做均方误差即可：

def boundary_loss(model): x_bc = torch.tensor([[0.0], [1.0]], requires_grad=True) u_bc = model(x_bc) return torch.mean((u_bc - 0.0) ** 2)

总损失由两部分组成，PDE残差损失和边界损失。注意，初始条件这里没有，因为是稳态问题。如果你要解瞬态问题，还要在初始时刻(t=0)上额外加一项。

def total_loss(model, x_res): res = pde_residual(model, x_res) loss_pde = torch.mean(res ** 2) loss_bc = boundary_loss(model) return loss_pde + loss_bc

3.4 训练循环：Adam打底，少量迭代就能看到效果

训练循环和普通深度学习几乎一样：

model = PINN() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(10000): # 内部采样点，用于计算PDE残差 x_res = torch.rand(256, 1) * 2 - 1 # [-1, 1]区间 # 注意我们的域是[0,1]，所以下面采样时要改一下，这里保持[0,1] x_res = torch.rand(256, 1) # [0, 1]区间 loss = total_loss(model, x_res) optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 500 == 0: print(f"Epoch {epoch}, Loss: {loss.item():.6f}")

这里有个细节值得注意：PDE残差点每次训练迭代都重新随机采样。这相当于一种无限样本增强，网络每次看到的都是新的空间位置，能有效避免过拟合。PINN不像传统深度学习那样需要固定的训练集，它用的是“在定义域内在线采样”的方式，采样策略直接影响训练效果。

3.5 训练效果评估与可视化

训练完成后，把网络预测和精确解画在一起：

import numpy as np import matplotlib.pyplot as plt x_test = torch.linspace(0, 1, 200).reshape(-1, 1) u_pred = model(x_test).detach().numpy() u_true = np.sin(np.pi * x_test.numpy()) plt.figure(figsize=(8, 4)) plt.plot(x_test.numpy(), u_true, label='Exact: sin(pi*x)', linewidth=2) plt.plot(x_test.numpy(), u_pred, '--', label='PINN prediction', linewidth=2) plt.legend() plt.xlabel('x') plt.ylabel('u(x)') plt.show()

我实测下来，这个简单问题在Adam训练5000轮以后，最大绝对误差能降到0.01以下。这已经足够说明PINN的原理是行得通的。如果误差一直下不去，问题大概率出在采样范围、学习率或者网络层数这些超参数上。

4. 高频踩坑记录与调试心得

4.1 采样点：分布比数量更重要

我第一次跑PINN的时候，内部点固定取了500个均匀网格点，训练结果在网格点附近还行，但在两个网格点中间的区域出现明显波动。后来改成每次迭代随机采样，效果立刻好了很多。

随机采样让网络在每个epoch看到的点都不一样，这相当于变相增加了训练样本量，也避免了网络“背住”固定点的输出。对于二维或三维问题，建议在边界附近加密采样，因为物理量往往在边界附近变化最剧烈（比如流体力学里的边界层效应）。

4.2 梯度问题：激活函数选择与学习率

前面提过Tanh是PINN的首选激活函数。如果用ReLU，二阶导为0，残差恒等于某个恒定值，根本学不动。另一个容易踩的坑是学习率设置。PINN的PDE残差和边界损失之间的量级可能差很多，学习率太大容易震荡，太小收敛极慢。

我常用的策略是：先用Adam 1e-3训练几千轮，等损失曲线平稳后再切换到L-BFGS做几百轮精细优化。L-BFGS是二阶优化算法，对PINN这种目标函数光滑、变量维度不高的问题非常有效，往往可以在Adam之后把误差再降低一个数量级。

# Adam 粗调 optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(3000): ... # L-BFGS 精调 optimizer = torch.optim.LBFGS(model.parameters(), lr=0.1) def closure(): optimizer.zero_grad() loss = total_loss(model, x_res) loss.backward() return loss for step in range(500): optimizer.step(closure)

注意L-BFGS的闭包函数里必须调用backward()，这是它的固定用法。

4.3 损失权重：不同损失项量级不匹配怎么办

在更复杂的PINN问题里，PDE残差、边界条件、初始条件的损失可能不在一个量级上。比如边界条件损失已经降到1e-5，而PDE残差还在1e-1，这时候梯度更新会严重偏向PDE项，导致边界条件被破坏。

解决办法是给不同损失项加权重系数，训练过程中根据实际损失量级动态调整。最简单的方式是让所有权重加起来为1，然后按量级比例分配：

loss = 100.0 * loss_pde + 1.0 * loss_bc

更高级的做法是训练过程中自适应调整权重，比如简单的“反向传播时比较梯度范数”的方法。新手阶段我建议先手动调，把PDE残差和边界损失的平均量级压到差不多再继续训练。

4.4 边界条件处理：硬约束更省事

PINN处理边界条件有两种思路：软约束和硬约束。软约束是把边界损失加到总损失里，靠优化器去逼近边界值，实现简单但需要调节权重。硬约束是把网络输出构造为自动满足边界条件的函数，这样边界损失直接从损失函数里删除，省心太多。

比如对于(u(0)=0)、(u(1)=0)这个边界条件，可以令(u_{net}(x) = x \cdot (1-x) \cdot N(x))，其中(N(x))是原始网络的输出。这样无论网络怎么训练，(u_{net}(0))和(u_{net}(1))都严格等于0，边界条件被精确满足。这个方法在边界条件简单的时候非常好用，强烈推荐。

4.5 常见问题速查表

5. 从一维到真正的物理问题：进阶方向与扩展思路

5.1 处理瞬态问题：加一个时间维度

稳态方程是最简单的PINN入门问题。如果你要处理瞬态热传导、波动方程这类含时间项的问题，做法也很直接：把时间(t)作为一个额外的输入拼到网络输入里，然后在时空联合域内采样。这样网络学到的就是(u(x,t))这个时空函数。

损失函数里除了PDE残差和边界条件，还要加上初始条件：

[ \mathcal{L}{IC} = \frac{1}{N}\sum{i=1}^{N} \left( u(x_i, 0) - u_0(x_i) \right)^2 ]

网络输入维度从(1)变成(2)，但整体代码框架基本不变。

5.2 几何复杂怎么办：坐标变换与区域采样

对于圆形、复杂曲面这类几何，最容易犯的错误是在全域均匀采样，导致边界条件学习的效率很低。正确的做法是在边界附近加密采样，或者对几何做坐标变换。比如圆域问题可以转成极坐标，让(r)和(\theta)作为网络输入。

还有一种技巧叫“硬几何约束”，在边界上用一个函数(\phi(x)=0)来隐式描述区域，把网络输出乘以(\phi(x))来强制满足边界。这在处理三维复杂几何时非常有价值。

5.3 反问题：从数据反推物理参数

PINN一个非常有吸引力的应用场景是反问题，就是已知部分观测数据，反推方程中的未知参数。比如方程里有个导热系数(k)是未知的，你可以把它定义为一个可训练的变量（类似网络参数），在训练过程中和网络权重一起更新。

k = torch.nn.Parameter(torch.tensor([2.0], dtype=torch.float32)) def pde_residual_with_k(model, x): ... residual = -k * u_xx - f return residual # 优化器里加入k optimizer = torch.optim.Adam(list(model.parameters()) + [k], lr=1e-3)

训练结束后，(k)的数值会被自动反推出来。我当年第一次跑通这个功能时非常震撼，因为传统方法要做反演通常需要迭代求解正问题很多次，计算量巨大，而PINN“正问题”和“反问题”在代码层面竟然只差了一个Parameter的定义。

5.4 关于PINN局限性的几句个人体会

最后聊几句大实话。PINN不是万能的，它在某些问题上会遇到严重的训练困难，比如高频问题、多尺度问题、强对流占主导的流体问题。这些场景下原始的PINN收敛很慢，甚至训练不收敛。学术界这几年提出了很多改进方案，比如用傅里叶特征嵌入输入、自适应损失权重、分域训练、注意力机制等。

我个人的体会是，PINN最大的价值不在于“替代传统求解器”，而在于它打破了“数据”和“物理规律”之间的高墙。你可以往里面塞实验数据，可以塞仿真数据，可以塞边界条件，甚至可以在线更新数据——所有这些都通过同一个loss函数优雅地融合在一起。如果你正在做某个工业仿真、实验数据处理或者预测类项目，完全可以把PINN当成一个“带物理常识的回归工具”，在传统方法不擅长的场景下往往能拿到意想不到的效果。

最后再分享一个我常用的调试小技巧：先不要急着上大网络、大数据，先拿一个最简单的解析解问题（比如本文的(\sin(\pi x))）把整个流程跑通，然后逐步增加复杂度和噪声。PINN的调试其实比深度学习更容易，因为物理方程本身就是最可靠的“标注数据”和“评价标准”——你的网络学得对不对，拿解析解或者实验测量一对比就有定论。