无需网格的PINN：用PyTorch从零实现物理信息神经网络解微分方程-育师

简介：这份基于PINN物理信息网络求解微分方程的Python学习包，聚焦深度学习与科学计算的交叉应用，适合想要掌握PINN建模思路、熟悉常见微分方程数值解法的开发者、研究生及高年级本科生。包内共22个文件，包括17个可直接运行的Jupyter Notebook案例、3个Python核心脚本、1份Markdown说明文档和1张结果可视化图，整体压缩包仅889KB，轻量易下载。案例覆盖欧拉-伯努利梁、扩散方程、拉普拉斯方程、泊松方程、常微分方程组、洛伦兹系统等典型问题，从一维到多维，从定解条件到方程系统均有涉及；配套脚本按照PINN流程拆分为几何区域处理、PDE方程定义、网络模型搭建等模块，结构清晰便于二次开发。截至目前已有2973人学习下载，适合用于课程项目、论文复现或作为从零搭建PINN架构的参考，帮助读者理解损失函数设计、训练策略与误差评估等关键环节。

1. 为什么PINN不用网格也能解微分方程

一个做流体仿真的朋友去年和我抱怨，说他在一个带复杂边界的模型上画网格画了两周，网格质量始终不达标，求解器算出来的压力场在拐角处全是伪振荡。这个场景里，传统数值方法的核心瓶颈不是求解器，而是网格生成——而PINN（物理信息网络，Physics-Informed Neural Network）给出的解法是：干脆不要网格。用神经网络直接拟合微分方程的解，把方程本身塞进损失函数里当作软约束，这就是PINN在2024年“杀疯了”的原因。

本质上，PINN解决的是两类人的问题：一类是工程师，手里有成熟方程但边界形状不规矩，网格成本高于求解成本；另一类是科研人员，方程形式明确但参数不确定，想用少量观测数据把方程和反演参数一起解出来。本文用Python和PyTorch从零搭一套可运行的PINN流程，覆盖损失函数设计、训练调参、误差验证和工程化技巧，适合已经熟悉Python语法但没碰过PINN的读者，也适合想摆脱“玄学调参”的从业者。方向定在PINN而不是深度算子网络，是因为PINN对微分方程约束的利用最直接、最容易被读代码的人理解。

2. PINN的核心机制：网络输出、自动求导与残差损失

2.1 物理信息网络的损失函数结构：数据、方程与初边值三项加权

PINN的做法可以用一句话概括：用一个全连接神经网络 $\hat{u}(x,t;\theta)$ 作为微分方程解 $u(x,t)$ 的替代模型，神经网络的输入是自变量（空间坐标、时间），输出是待求物理场。网络的结构通常是多层感知机，激活函数在回归问题里几乎默认选双曲正切，因为解的导数要进损失函数，而tanh的任意阶导数都存在且光滑，ReLU的一阶导是分段常数，二阶导直接为零，没法用于二阶方程的残差计算。

方程约束怎么进入网络？把 $\hat{u}$ 代入原方程，左右两边会产生一个差值，这个差值就是方程残差。以Burgers方程 $u_t + u u_x - \nu u_{xx} = 0$ 为例，残差定义为：

$$r(x,t) = \hat{u}_t + \hat{u},\hat{u}x - \nu,\hat{u}{xx}$$

如果网络输出的解是精确的，残差处处为零。所以训练目标就是让残差在求解域内尽量接近零，这就是“物理信息”的含义——不是把方程结果当标签，而是把方程本身当监督信号。完整损失函数由三部分组成：方程残差损失、边界条件损失、初值条件损失，有观测数据时再加第四项数据损失：

$$L = L_r + \lambda_b L_b + \lambda_i L_i + \lambda_d L_d$$

其中 $L_r$ 是在求解域内随机采样的残差点的平均平方残差，$L_b$ 和 $L_i$ 分别约束边界和初值，$\lambda$ 是权重。这里有个新手上路最容易犯的错：只盯着残差损失训，不设初边值权重，网络确实能让残差变小，但解会整体漂移，因为方程只约束“导数关系”，不约束“绝对位置”。合理的做法是先单独跑几个小epoch，观察各项loss的量级，再反推权重，让三项在初始阶段处于同一个数量级，这个技巧在后面调参章节展开。

2.2 自动微分：PINN区别于差分法的核心差异

PINN里所有导数都不是用有限差分算的，而是用PyTorch的autograd自动求导。原因有两个：第一，自动微分基于链式法则逐层回传，精度到机器精度，不像差分法有截断误差；第二，求解域内任意一点都能直接求导，不需要网格拓扑。用PyTorch对网络输出求二阶导的标准写法是：

import torch def compute_derivatives(model, x, t): x = x.clone().requires_grad_(True) t = t.clone().requires_grad_(True) u = model(torch.cat([x, t], dim=1)) u_t = torch.autograd.grad(u, t, grad_outputs=torch.ones_like(u), create_graph=True)[0] u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u), create_graph=True)[0] u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x), create_graph=True)[0] return u, u_t, u_x, u_xx

逻辑上分三层：第一层，对输入x和t显式声明requires_grad_(True)，只有这样后续对它们求导才有轨迹；第二层，计算u关于t和x的一阶导时，必须传create_graph=True，因为后续还要对一阶导再求导，不开启这个标志，计算图会在第一次求导后被释放；第三层，二阶导是对u_x再求一次x方向的梯度，不是对u直接求二次梯度，思路是在一阶导结果上继续走链式法则。

这里有一个能省很多内存的参数设置：求u_t和u_x时，如果二者互相独立，后算的那个不需要保留之前的计算图，可以把retain_graph设为False（默认就是False），但上面代码中二者用了同一个计算图，第二次调用autograd.grad时前一个图的梯度已经被释放，所以不会冲突。实际训练时如果显存吃紧，把x和t分开传网络、分别求导是更省显存的做法，代价是网络前向计算两次。

对比维度	PINN	传统有限差分/有限元
解的表达形式	连续函数，任意点可直接取值	离散节点值，插值得到中间点
网格依赖	不需要网格，只需采样点	强依赖网格质量
导数计算	自动微分，机器精度	差分近似，有截断误差
边界条件处理	以软约束加入损失函数	直接融入线性方程组
高维扩展性	维度增加不影响网络结构	网格数量随维度爆炸

表格最后一行是PINN在高维问题上的卖点，但代价是训练时间通常远高于传统单次求解。实际工程里PINN的定位不是完全替代求解器，而是做代理模型或者反问题参数辨识，这个定位直接影响后面选网络和调参的策略。

2.3 最小网络该多大：隐藏层宽度与深度的起点

PINN网络设计没有公式可套，但从业者一般从3到5个隐藏层、每层50到100个神经元起步。层数太浅，函数表达能力不够，残差损失降不下去；层数太深，梯度消失和训练不稳定接踵而至。选60×3或80×4这种规模就够处理一维和二维问题。输入输出的归一化是网络能不能训动的先决条件：空间和时间坐标全部缩放到[-1, 1]区间，物理量的取值如果跨越多个数量级，也先做归一化再进网络，否则高阶导数的梯度很容易溢出为NaN。

3. 用PyTorch实现PINN：Burgers方程的最小可复现代码

3.1 问题设定与采样策略：残差点、边界点、初值点的生成逻辑

用Burgers方程做测试案例是PINN领域的事实标准，因为它同时包含一阶非线性项和二阶粘性项，能暴露大多数训练问题。方程写在区间 $x \in [-1, 1]$、$t \in [0, 1]$ 上，取粘性系数 $\nu = 0.01 / \pi$，初值 $u(0,x) = -\sin(\pi x)$，边界条件采用周期性边界 $u(t,-1) = u(t,1)$。

采样策略分三块：残差点在 $x$-$t$ 平面内用均匀随机采样，采样数一般取10000到20000个；初值点和边界点各取1000到2000个，边值点在两条竖边上随机撒，初值点在 $t=0$ 这条横边上随机撒。边界采样数不必多，但覆盖要均匀，因为边界条件本质是一条约束线，残差是面约束。所有采样点每一轮都重新生成会比固定一批好，原因是重新采样让网络无法“记住”特定点，这属于最简单的退化抗性处理，后面章节里讲到自适应采样时再深化。

3.2 完整训练代码：Adam粗训加L-BFGS精修

import torch import torch.nn as nn import numpy as np class PINN(nn.Module): def __init__(self, layers=[2, 50, 50, 50, 1]): super().__init__() self.activation = nn.Tanh() self.linears = nn.ModuleList() for i in range(len(layers) - 1): self.linears.append(nn.Linear(layers[i], layers[i + 1])) if i < len(layers) - 2: nn.init.xavier_uniform_(self.linears[-1].weight) def forward(self, x): for linear in self.linears[:-1]: x = self.activation(linear(x)) return self.linears[-1](x) def burgers_residual(model, x_r, t_r, nu): u, u_t, u_x, u_xx = compute_derivatives(model, x_r, t_r) return u_t + u * u_x - nu * u_xx def train_pinn(num_iters=15000): torch.manual_seed(42) model = PINN() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) nu = 0.01 / np.pi for it in range(num_iters): # 每轮重新采样 x_r = torch.rand(10000, 1) * 2 - 1 # [-1, 1] t_r = torch.rand(10000, 1) # [0, 1] x_b = (torch.rand(1000, 1) * 2 - 1) * 0 + torch.tensor(1.0) t_b = torch.rand(1000, 1) x_i = torch.rand(1000, 1) * 2 - 1 t_i = torch.zeros_like(x_i) # 三类损失 loss_r = torch.mean(burgers_residual(model, x_r, t_r, nu) ** 2) u_left = model(torch.cat([torch.full_like(t_b, -1.0), t_b], dim=1)) u_right = model(torch.cat([torch.full_like(t_b, 1.0), t_b], dim=1)) loss_b = torch.mean((u_left - u_right) ** 2) u_ic = model(torch.cat([x_i, t_i], dim=1)) loss_i = torch.mean((u_ic + torch.sin(np.pi * x_i)) ** 2) loss = loss_r + loss_b + loss_i optimizer.zero_grad() loss.backward() optimizer.step() if it % 1000 == 0: print(f"iter {it:6d} | loss_r {loss_r.item():.3e} " f"| loss_b {loss_b.item():.3e} | loss_i {loss_i.item():.3e}") # L-BFGS精修 optimizer_l = torch.optim.LBFGS(model.parameters(), lr=1.0, max_iter=50) def closure(): optimizer_l.zero_grad() x_r = torch.rand(10000, 1) * 2 - 1 t_r = torch.rand(10000, 1) loss_r = torch.mean(burgers_residual(model, x_r, t_r, nu) ** 2) loss = loss_r loss.backward() return loss optimizer_l.step(closure) return model

参数说明：网络层结构[2, 50, 50, 50, 1]表示输入2维（x和t）、三个隐藏层每层50个神经元、输出1维。Adam阶段学习率1e-3是PINN的常用起点，低于1e-4收敛过慢，高于1e-2残差损失极易发散。L-BFGS阶段用max_iter=50做精修，它的优势是二阶近似，在损失曲面较平滑时能比Adam多降一个数量级的残差，但它对batch的随机性很敏感，所以closure里重采样的点每步都在变，实际中更稳妥的做法是用固定一批验证点来跑L-BFGS。周期性边界条件通过比较左右两端网络输出实现，没有直接让网络结构保证周期性，所以边界损失权重如果太小，边界处会出现可见的不连续。

3.3 训练过程怎么看：三项loss各自的行为特征

正常训练时观察打印输出，loss_r的前1000轮会从10的零次方级别迅速降到10的负三次方，这是网络先拟合方程的大尺度平滑结构；loss_b和loss_i在前5000轮会来回抖动，因为Adam的学习率对这几个小样本分支偏大。如果loss_r降得很快，但loss_b长期不降，说明边界采样的梯度被残差点的梯度淹没了，解法在下一章讲权重分配。

如果loss在训练中打印出NaN，优先检查nu的取值和坐标归一化，Burgers方程里nu的数值是0.003183，而u的典型量级是0到1，方程里u * u_x和nu * u_xx的量级如果差到三个数量级以上，二阶导项在反向传播时梯度特别容易爆炸。这类问题的处理方式是给方程各项分别开损失，而不是把残差统一平方，这一招在工程代码里经常用得着。

4. PINN不收敛的10个调试方向：权重、采样与训练策略

PINN这个领域有个反直觉的现象：损失函数一路降到10的负五次方，画出来的解却和真实解对不上。原因是PINN的损失曲面高度非凸，网络完全可能出现“方程成立、边界也成立，但解是另一个分支”的局部最优。把调试方向按经验从高概率到低概率排列，能省下大量无头绪试错的时间。

4.1 从学习率到激活函数：前5个常规检查项

学习率先降后升。PINN的初始损失值通常很大，残差项的量级在10到100之间，这个区间用Adam的默认学习率1e-3是合理的。如果print出的loss_r在5000轮后还在缓慢爬升，把学习率降到3e-4，同时把每个维度的梯度打印出来看是否有个别梯度过大。
激活函数换tanh。换成ReLU之后，二阶导恒为零，方程残差直接变成“0 + 0 - 0”类型的问题，网络无法感知方程约束，这是一个必踩的坑；想保ReLU系的非线性又想要光滑导数，可以用SiLU（即swish），但它对初始化更敏感，收敛不如tanh稳定。
权重初始化。nn.init.xavier_uniform_是配合tanh的默认选择，换成Kaiming初始化会让tanh层输出方差过大，前向传播时接近饱和区，梯度消失来得更快。
坐标归一化。输入范围超过[-1, 1]越远，tanh的饱和区越早被激活，一阶导和二阶导同时趋近于零，残差损失传不回梯度。把时间除以最大值、空间减去中点再除以半宽，是几乎所有PINN工程的标配。
去掉BatchNorm或LayerNorm。标准化层在批量样本之间引入依赖，而PINN的“样本”是独立采样点，标准化后的输出分布随batch扰动，训练曲线会出现周期性的尖峰。

4.2 损失权重失衡：用梯度幅度做动态调节

初边值损失和残差损失在数量级上的竞争，是PINN不收敛的头号原因。残差点在10000个量级，初边值点只有1000个，所以残差梯度天然占主导。一个工程级的解决思路是用梯度范数做动态权重：每500轮计算一次三类损失对网络参数的梯度范数，如果某类损失的梯度范数比其他类小两个数量级，就把它的权重乘以2。一个简化实现：

def update_weights(model, loss_r, loss_b, loss_i, weights, lr=0.1): grads = [] for loss in [loss_r, loss_b, loss_i]: grads.append(sum(p.grad.norm().item() ** 2 for p in model.parameters() if p.grad is not None) ** 0.5) mean_grad = sum(grads) / len(grads) for i in range(3): if grads[i] < 0.1 * mean_grad: weights[i] *= (1 + lr) return weights

逻辑说明：每个loss分支都保留计算图、单独反向传播后再取梯度的范数；梯度范数小说明这个约束对网络的影响弱，权重放大后该项在总损失里占比上升。注意这里没有做归一化，权重可能越涨越多，所以实际用时要带上限或者把三个权重归一化到和为固定值，否则训练后期权重失衡会反过来压垮残差损失。

动态权重的前提是三个loss分支能分别反向传播，实现时不要让三个loss相加后统一backward，应按分支顺序分别backward(retain_graph=True)或者用register_hook截取各层梯度，这与第一节里求二阶导的create_graph同理，都是控制计算图生命周期的问题。

4.3 采样密度不均：残差点的分布比数量更关键

均匀随机采样在稳态问题里够用，但输运类方程的解会在特定区域出现陡峭梯度，比如激波。如果残差点在陡峭区域的密度不够，网络会用光滑函数强行拟合突变，残差损失看似不大，局部误差却很高。常见做法是先用粗训练找出残差绝对值大的点，然后把新一批采样点按残差大小加权生成：

def resample_with_residual(model, n_samples, bounds, nu): """根据当前残差分布生成密度不均匀的采样点""" n_probe = n_samples * 5 x_probe = torch.rand(n_probe, 1) * (bounds[1] - bounds[0]) + bounds[0] t_probe = torch.rand(n_probe, 1) with torch.no_grad(): r = burgers_residual(model, x_probe, t_probe, nu).abs().squeeze() p = r / r.sum() idx = torch.multinomial(p, n_samples, replacement=True) return x_probe[idx], t_probe[idx]

说明：先密集撒一批探测点，计算每个点的残差绝对值，按残差分布做带权重的随机抽样，残差大的区域自然被多采。这个过程每2000轮触发一次，等价于把网络注意力动态集中到还没学会的区域。代价是有偏采样会让损失值整体偏大，所以对比收敛进度时要用固定测试集上的误差，不能看训练loss本身。

症状	可能原因	首选调整
全部loss不降	学习率过高或输入未归一化	降到3e-4，检查坐标范围
loss_r降但loss_b不动	边界权重太小	将边界损失权重乘10
loss降到1e-5但解错	初边值约束失效或局部最优	恢复初边值权重，重采样
训练早期出现NaN	nu等系数未归一化	方程系数整体缩放
10000轮后loss_r缓慢下降	损失曲面平坦	换L-BFGS精修
预测解有锯齿状波动	网络过参数化或采样点太少	减宽度，提高残差采样数
边界区域误差远大于内部	边界硬约束缺失	引入边界硬约束（见第6章）
更换种子后结果差异大	初始化敏感	多跑几个种子取中位结果
训练曲线周期性尖峰	每轮重新采样导致的噪声	增大batch到20000或固定采样点

4.4 优化器组合与训练长度：什么时候该认输

PINN训练有一个不成文的经验：Adam训到loss_r不再下降后的前5000轮是“性价比最高”的阶段，后面每降一个数量级要翻倍的时间。如果Adam 30000轮后loss_r还在10的负四次方以上，瓶颈往往不是优化器而是网络容量或采样分布。此时先扩网络，宽从50加到80，再不行检查方程系数是否做了归一化。标题是“使用Python”，实操里换TensorFlow或DeepXDE这类专业库不在本文范围，但了解深水区后用封装库能减少大量模板代码，前提是理解本文的底层原理。

5. 用解析解验证PINN精度：误差度量与诊断方法

PINN没有“训练集”和“测试集”的概念，模型在整个求解域上都是连续函数，所以验证策略也完全是另一套。面对一个没有解析解的方程，新手很容易陷入“loss已经够小”的自我欺骗。面对真实问题的替代方案不是没有你可能没被你考虑到的可行的替代方案。

5.1 用Poisson方程做解析验证：相对L2误差的计算

在动手处理工程方程之前，先用一个带解析解的问题校准整个流程。以Poisson方程 $-u_{xx} = f(x)$，$x \in [0, 1]$，取 $f(x) = \pi^2 \sin(\pi x)$，边界条件 $u(0) = u(1) = 0$，解析解为 $u(x) = \sin(\pi x)$。把网络训练完成后，在测试网格上计算预测值与解析解的相对L2误差：

def relative_l2_error(model, x_test, u_exact): """相对L2误差，衡量预测整体与真解的偏离""" u_pred = model(x_test).squeeze() u_exact = u_exact.squeeze() return torch.norm(u_pred - u_exact, p=2) / torch.norm(u_exact, p=2) x_test = torch.linspace(0, 1, 1000).reshape(-1, 1) u_exact = torch.sin(np.pi * x_test) err = relative_l2_error(model, x_test, u_exact) print(f"相对L2误差: {err.item():.3e}")

相对L2误差是把两个解的差向量的模除以解析解的模，消除了解本身量级带来的偏差。一个调好的PINN在这个问题上应当达到1e-3量级的相对L2误差，如果误差在1e-1量级，说明边界条件权重偏低或者网络训练轮数不足。这个方法在PINN的验证协议中的地位相当于机器学习里的留出验证集，之所以不用交叉验证，是因为PINN的每次训练动辄几万步，交叉验证的成本不切实际。

5.2 误差诊断：残差分布比单一误差值信息量大

解析解能拿到的时候，可以画出误差随空间的分布，看它是否集中在边界、初始时刻或者某个特殊区域。常见的诊断结论：误差集中在边界附近说明边界损失权重不够；误差在某一小片连续区域过高说明该区域残差采样密度不足；误差分布呈现高频振荡说明网络宽度过大，过拟合了噪声。对于没有解析解的实际问题，改用事后验证：方程残差在各处的绝对值分布是否接近均匀？初边值条件的误差落在哪个数量级？

5.3 四个症状对照表：这个loss曲线还能不能继续训

把验证结果和训练loss曲线的形态放在一起看，比只看单一数值有效。loss_r曲线在20000轮后仍然以近似线性的斜率缓慢下降，说明训练还没充分，继续加大轮数有意义；loss_r曲线已经水平但没有达到预期精度，优先检查初边值权重而非加轮数；loss_r快速下降后出现反弹，多半是采样点重采样后的分布发生剧烈变化，把重采样周期加大或者改用确定性采样；训练末期loss_i突然变大，这是Adam在平坦区域处的震荡引起的，用L-BFGS收尾可以解决。

6. 四个进阶技巧：让PINN快速落地到实际方程

6.1 坐标归一化先于一切

PINN对输入量纲极其敏感，写出第一个残差函数之前，先把坐标线性映射到[-1, 1]区间，时间同理。一个简单写法是x_norm = (x - x_mid) / (x_span / 2)。这一步能避免大部分NaN问题，也是让L-BFGS阶段稳定收敛的前提。

6.2 从软约束升级到硬约束：边界条件直接写进网络结构

前面已经把边界条件作为损失项加入了训练，其本质是软约束，网络能逼近边界值但未必精确满足。对于边界条件简单的问题，可以直接修改网络输出形式，让边界条件从结构上被自动满足。例如一维Dirichlet边界 $u(0)=A$、$u(1)=B$，把网络输出 $\hat{u}$ 替换为：

def hard_constraint_output(x, net_out): """线性插值满足两个端点，网络只修正内部形状""" u_boundary = (1 - x) * A + x * B return u_boundary + x * (1 - x) * net_out

这个处理的好处是边界点上的误差被强制清零，训练可以把原本分给边界损失的计算资源全部用于残差损失。代价是边界形式越复杂，构造约束函数的难度越高，在矩形域上还可以用乘积形式处理多个边界，在不规则边界上建议仍用软约束，两者之间存在一个“结构复杂度”和“训练效率”的取舍。

6.3 用固定测试集记录真实误差

PINN的训练损失不能直接对比，因为每次采样都是随机点集，损失值包含采样噪声。工程上习惯单独生成一组固定的大规模测试点，比如10000个均匀网格点，每5000轮在这组固定点上计算一次相对L2误差或残差平均值，记录成日志。固定测试集上的误差曲线比训练损失的收敛曲线能更早暴露出过拟合，也能在更换随机种子后保持结果可对比。