基于PINN求解Burgers-Fisher方程的Python实践与调参指南

解Burgers-Fisher方程这件事，前几年我基本只用有限差分和有限元，网格剖分、数值稳定性、时间步长限制，哪一步都要反复调。后来改用物理信息神经网络（PINN）在Python里直接求解，思路一下子简单了很多：不用画网格，不用推导复杂的迎风差分格式，把偏微分方程本身当成损失函数的一部分，交给神经网络去逼近。这篇文章我就拿Burgers-Fisher方程当例子，把完整的设计思路、Python实现细节、训练调参经验和踩坑记录都摊开讲一遍，适合正在入门PINN、或者已经跑通简单Poisson方程但一碰非线性方程就发愁的读者。

1. 为什么用PINN解Burgers-Fisher方程：思路与选型

1.1 这个方程到底难在哪

Burgers-Fisher方程是Burgers方程和Fisher方程的耦合形式，典型写法是：

[
u_t + u u_x = \nu u_{xx} + \beta u(1-u)
]

左边第二项是对流项，当解出现陡峭梯度时，线性扩散压不住这种非线性对流，容易形成很薄的过渡层。右边第一项是扩散项，第二项是反应项，它会让解在0和1两个稳态之间切换。三个物理过程叠加在一起，对传统数值方法非常不友好：网格不够密、格式迎风性不好，迭代就会振荡；时间步长太大，反应前沿的位置就会偏移。我去查文献的时候发现，很多人拿这个方程测新算法，就是因为它能把“对流-扩散-反应”三种困难一次性凑齐。

传统做法里，我一般会在高梯度区域加密网格，再用隐式格式保证稳定性，调试周期很长。如果在二维或三维区域做，网格生成本身就是大工程。这也是我后来对PINN产生兴趣的直接原因：PINN不需要网格，只要在定义域里取点就行。

1.2 PINN的解法逻辑：把PDE变成优化问题

PINN的核心思路很朴素。设神经网络的参数为 (\theta)，网络的输入是时空坐标 ((x,t))，输出是近似解 (u_\theta(x,t))。如果这个近似解想成为方程的解，它必须满足三件事：方程残差为0、初始条件成立、边界条件成立。于是我把这三个要求全部写进损失函数，训练神经网络让损失最小化，得到一个满足方程约束的代理模型。

这里的“方程残差”不是靠差分离散算的，而是靠自动微分。神经网络本身是光滑函数，PyTorch或TensorFlow里一行代码就能求出它对输入的一阶导、二阶导，所以式子里的 (u_t)、(u_x)、(u_{xx}) 都能精确算出来，不会引入截断误差。这一点是物理信息神经网络最核心的优势：把偏微分方程求解变成无监督学习任务，数据点不是从实验来的，而是从方程本身采样的。

对比传统数值方法，PINN至少有三个优点：

• 无网格，复杂区域只需要采样点分布描述；
• 自动微分，不需要手推离散格式；
• 训练完得到一个连续可导的函数，任意坐标都能取值，不用插值。

当然，PINN也有代价，后面第4章我会专门讲训练不稳定和需要调参的问题。

1.3 为什么选Burgers-Fisher做验证

我一开始跑PINN用的是一维热传导方程，太简单，网络闭着眼都能拟合，学不到什么。换成Burgers-Fisher之后，才真正体会到哪些环节容易翻车。

选它做验证对象有几个原因。第一，它包含二阶导数项，可以检验自动微分和网络容量是否足够。第二，非线性强，能检验损失函数设计是否合理，尤其是残差点采样不足时能明显看到波动。第三，它仍然是一维问题，计算量不大，CPU就能在几分钟到十几分钟内跑完一轮实验，适合反复调参。

如果你也想复现这篇内容，强烈建议先在一维Burgers-Fisher上把流程跑通，再往二维、参数反演方向扩展。这个方程足够有挑战性，又不会让硬件成为瓶颈。

2. 方程、网络与损失函数：先把核心参数定明白

2.1 方程形式与初边值设置

我这次采用的方程形式和参数如下：

[
u_t + u u_x = \nu u_{xx} + \beta u(1-u)
]

计算域取：

[
x \in [-1, 1], \quad t \in [0, 1]
]

参数固定为：

• (\nu = 0.01)
• (\beta = 1.0)

初始条件取正弦分布：

[
u(x,0) = \sin(\pi x)
]

边界条件取Dirichlet零边界：

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

选这个初边值组合，是为了保证角点一致：在 (x=-1) 和 (x=1) 处，初始时刻函数值本身就是0，训练时初值损失和边界损失不容易打架。这个细节看着小，但实际影响很大。如果初始函数在边界上不为0，而你强制边界为0，网络会在角点附近反复振荡，损失下降得很慢。

有些文献用符号函数形状的初值来模拟行波解，但那种初值在边界上很难做到精确一致。我建议新手先用这种“自洽”的初边值组合，先把PINN跑通，再逐步增加难度。

2.2 网络结构与激活函数怎么选

网络结构我用了最简单的全连接MLP：

[
(x, t) \in \mathbb{R}^2 \rightarrow \text{隐藏层} \rightarrow u \in \mathbb{R}^1
]

具体层数建议4到6层，每层50到100个神经元。隐藏层太少，表达能力不够，非线性逼近差；隐藏层太深，训练时梯度容易出问题，后面第4章会细说。这里我选的是4层隐藏层，每层64个神经元，总共约4000个参数，训练速度很快。

激活函数这块，我一开始也图省事用了ReLU，结果损失直接卡死不降。原因很简单：ReLU的二阶导数几乎处处为0，而方程里有 (u_{xx})，网络根本提供不了有效的二阶信息。PINN的隐藏层建议用 (\tanh) 或 SiLU/Swish，因为二阶导数连续，梯度回传能覆盖到二阶项。我实际测试下来，tanh对这类平滑解最稳，收敛速度比SiLU略快。

网络初始化推荐Xavier初始化。tanh在零附近是线性的，如果权重初始化太大，输入稍大一点就会把神经元打成饱和区，梯度趋近于0，网络学不动。用Xavier可以让激活值在初始阶段保持在tanh的敏感区间。

2.3 损失函数：PDE残差、初边值、数据拟合如何加权

损失函数总共有三项：

[
L = \lambda_f L_f + \lambda_{ic} L_{ic} + \lambda_{bc} L_{bc}
]

其中PDE残差损失为：

[
L_f = \frac{1}{N_f}\sum_i \left( u_t^{(i)} + u^{(i)} u_x^{(i)} - \nu u_{xx}^{(i)} - \beta u^{(i)}(1-u^{(i)}) \right)^2
]

初始条件损失为：

[
L_{ic} = \frac{1}{N_{ic}}\sum_i \left( u_\theta(x_i, 0) - \sin(\pi x_i) \right)^2
]

边界条件损失为：

[
L_{bc} = \frac{1}{N_{bc}}\sum_i \left( u_\theta(-1, t_i)^2 + u_\theta(1, t_i)^2 \right)
]

默认权重我取 (\lambda_f = \lambda_{ic} = \lambda_{bc} = 1.0)。但这不是金科玉律，后面会讲到怎么根据实际收敛情况调整。有人喜欢把边界条件放进网络结构做硬约束，我建议先用软约束，逻辑更清晰，也方便排查问题。

3. Python代码实操：从零搭一个PINN求解器

3.1 环境准备与依赖安装

我用的Python版本是3.10，主要依赖PyTorch和matplotlib。安装命令很简单：

bash复制pip install torch numpy matplotlib

PyTorch 2.0以上都行，CPU版本就足够跑通这个例子。如果你的机器有CUDA，可以把代码里的数据放到GPU上，能明显加速；没有GPU也不用怕，4层64神经元的网络在CPU上一轮实验大概几分钟。

不建议一上来就用DeepXDE之类的封装库。虽然DeepXDE封装好了很多PINN组件，但一旦训练失败，你很难判断问题是出在采样、网络还是损失权重。手写一遍，把每个环节都弄明白，对后续用库会有很大帮助。

3.2 生成训练样本：内部点、边界点、初始点

PINN训练不需要网格，只需要三组样本点。

• 内部残差点 (N_f=10000)：在矩形 ([-1,1]\times[0,1]) 里随机采样。
• 初始点 (N_{ic}=200)：在 (x\in[-1,1]) 上采样，固定 (t=0)。
• 边界点 (N_{bc}=200)：在 (x=-1) 和 (x=1) 上各采样100个点，(t) 在 ([0,1]) 内随机。

采样代码可以这样写：

python复制import torch
import numpy as np

def sample_data(n_f=10000, n_ic=200, n_bc=200):
    # 内部点
    x_f = torch.rand(n_f, 1) * 2 - 1
    t_f = torch.rand(n_f, 1)
    # 初始点
    x_ic = torch.rand(n_ic, 1) * 2 - 1
    t_ic = torch.zeros(n_ic, 1)
    # 边界点
    t_bc1 = torch.rand(n_bc // 2, 1)
    x_bc1 = torch.full((n_bc // 2, 1), -1.0)
    t_bc2 = torch.rand(n_bc // 2, 1)
    x_bc2 = torch.full((n_bc // 2, 1), 1.0)

    return {
        'x_f': x_f, 't_f': t_f,
        'x_ic': x_ic, 't_ic': t_ic,
        'x_bc': torch.cat([x_bc1, x_bc2], dim=0),
        't_bc': torch.cat([t_bc1, t_bc2], dim=0)
    }

这里有个小经验：内部点不用固定，我推荐每个epoch或者每隔一定步数重新随机采样一次。固定采样点训练，网络可能只记住这些点上的取值，泛化性能变差。重新采样相当于给网络换着出题，PDE残差更容易学得均匀。

3.3 网络定义与自动微分

网络定义很简单，问题不大：

python复制import torch.nn as nn

class PINN(nn.Module):
    def __init__(self, layers=[2, 64, 64, 64, 64, 1]):
        super().__init__()
        self.net = nn.ModuleList()
        for i in range(len(layers) - 2):
            self.net.append(nn.Linear(layers[i], layers[i+1]))
            self.net.append(nn.Tanh())
        self.net.append(nn.Linear(layers[-2], layers[-1]))

    def forward(self, x, t):
        u = torch.cat([x, t], dim=1)
        for layer in self.net:
            u = layer(u)
        return u

重点在PDE残差的计算，这里要用两次自动微分。第一次对 (u) 求 (t) 的偏导得到 (u_t)，对 (u) 求 (x) 的偏导得到 (u_x)。第二次要把 (u_x) 对 (x) 再求一次偏导得到 (u_{xx})，这一次必须让计算图保留下来，否则二阶导求不了。

python复制def pde_residual(net, x, t, nu=0.01, beta=1.0):
    x = x.clone().requires_grad_(True)
    t = t.clone().requires_grad_(True)
    u = net(x, t)

    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), create_graph=True)[0]

    return u_t + u * u_x - nu * u_xx - beta * u * (1.0 - u)

有几点必须注意：

• x 和 t 要用克隆后的独立张量，避免覆盖训练数据。
• requires_grad_(True) 在每次计算前都要设置，因为前一步反向传播后梯度信息会被释放。
• create_graph=True 是必须的，否则 u_xx 无法计算。

3.4 训练循环：Adam先行、L-BFGS收尾

损失函数汇总成一段代码：

python复制def compute_loss(net, data, nu=0.01, beta=1.0):
    x_f, t_f = data['x_f'], data['t_f']
    x_ic, t_ic = data['x_ic'], data['t_ic']
    x_bc, t_bc = data['x_bc'], data['t_bc']

    residual = pde_residual(net, x_f, t_f, nu, beta)
    loss_f = torch.mean(residual**2)

    u_ic = net(x_ic, t_ic)
    loss_ic = torch.mean((u_ic - torch.sin(torch.pi * x_ic))**2)

    u_bc = net(x_bc, t_bc)
    loss_bc = torch.mean(u_bc**2)

    return loss_f + loss_ic + loss_bc

训练分成两个阶段。第一阶段用Adam，学习率 (10^{-3})，跑20000步；第二阶段切到L-BFGS精调2000步。Adam的优点是稳定、容错率高，能先把损失从几十级别压到 (10^{-4}) 左右。L-BFGS是拟牛顿法，对光滑的PINN损失收敛更准，但直接上手不稳，所以放在后面收尾。

python复制net = PINN()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)

for it in range(20000):
    optimizer.zero_grad()
    loss = compute_loss(net, data)
    loss.backward()
    optimizer.step()
    if it % 2000 == 0:
        print(f"Adam iter {it}, loss = {loss.item():.3e}")

切换到L-BFGS时，PyTorch的L-BFGS优化器要求传入一个闭包函数，一次optimizer.step(closure)里会多次计算损失和梯度：

python复制optimizer = torch.optim.LBFGS(net.parameters(), lr=1.0, max_iter=2000)

def closure():
    optimizer.zero_grad()
    loss = compute_loss(net, data)
    loss.backward()
    return loss

optimizer.step(closure)

我自己实验下来，Adam阶段结束后损失大概降到 (10^{-4}) 量级，L-BFGS继续跑几分钟能降到 (10^{-5}) 甚至更低。如果你发现L-BFGS不降反升，大概率是学习率不合适或当前损失曲面太平滑，把lr调小到0.1试试。

3.5 结果可视化与误差评估

训练完以后，怎么判断网络学到了东西？我的习惯是画三张图：损失下降曲线、某个时刻的解剖面、整个时空域的预测曲面。

画预测曲面时，先在 (x) 和 (t) 方向建立均匀网格，再把网格点reshape成列向量，输入网络，最后把输出reshape回网格形状：

python复制import matplotlib.pyplot as plt

def plot_prediction(net, x_range=(-1, 1), t_range=(0, 1)):
    x = torch.linspace(x_range[0], x_range[1], 201)
    t = torch.linspace(t_range[0], t_range[1], 101)
    X, T = torch.meshgrid(x, t, indexing='ij')
    x_flat = X.reshape(-1, 1)
    t_flat = T.reshape(-1, 1)
    with torch.no_grad():
        u_flat = net(x_flat, t_flat)
    U = u_flat.reshape(X.shape)

    fig = plt.figure(figsize=(8, 5))
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X.numpy(), T.numpy(), U.numpy(), cmap='viridis')
    plt.show()

如果只是为了跟参考解对比，可以在某个固定时刻把预测曲线和用高精度有限差分算出的参考曲线叠在一起画。这里我不展开有限差分的代码，但是要提醒一句：不要只画表面图看“像不像”就完了，一定要算数值误差，比如L2相对误差。我通常把训练好的网络在均匀网格上的预测值和参考解做对比，L2相对误差能到 (10^{-3}) 以下就算这个方程被PINN求解成功了。

4. 踩坑记录与排查技巧：训练不收敛怎么办

4.1 激活函数导致梯度消失或二阶导失效

第一次跑Burgers-Fisher的时候，我直接用ReLU做隐藏层，结果PDE残差损失卡在某个值上一动不动。后来细看才发现问题：ReLU的导数在正区间为1，负区间为0，二阶导数几乎是0。方程里的 (u_{xx}) 在ReLU网络里完全失去表达能力，也就是说网络根本表示不了一个真正满足扩散项的非线性解。

换成tanh之后，情况立刻好转。如果你发现训练前期损失下降挺快，后面却越来越慢，那可能是神经元进入tanh的饱和区了。这时候不光要看网络层数，还要检查输入范围。(x) 在 ([-1,1]) 还好，(t) 在 ([0,1]) 也还好，但如果换到更大的计算域，一定要做输入归一化，比如把 (x) 和 (t) 都缩放到 ([-1,1])。

4.2 collocation点怎么布：均匀网格还是随机采样

PINN对残差点的分布非常敏感。我把内部残差点从10000改成1000的时候，损失虽然也能降下来，但最后预测曲面在高梯度区域有明显的波浪形误差。这说明采样点太少，网络在稀疏区域被“放任自流”了。

我的经验是：内部残差点不能太少，一万起步。同时不要只在初始化时采样一次，最好每几百步重新采样一次，这样网络不会对固定点过拟合。如果解的区域里有已知的陡峭前沿，可以在前沿附近加密采样，甚至先跑一个粗模型，再在残差大的区域补充样本点。

4.3 损失权重设置的经验

前面默认 (\lambda_f = \lambda_{ic} = \lambda_{bc} = 1)，但实际训练时，我遇到过初值边界已经收敛得很好，PDE残差却还是很大的情况。这时候需要把 (\lambda_f) 适当调大，比如设置成10或50，强制网络优先满足方程。

反过来，如果PDE残差已经很小，但初边值误差明显，那就应该提高 (\lambda_{ic}) 和 (\lambda_{bc})。网上有很多自适应加权方案，比如基于梯度的Gradient Norm方法，但我觉得项目初期不需要搞那么复杂，先用固定的权重做敏感性实验，把“哪个损失降不下来”找到，再针对性调权重，效率更高。

4.4 常见问题速查表

这里放一张我经常翻的排查表，按症状对号入座。

5. 扩展与经验：PINN还能怎么玩

5.1 往更高维和复杂区域扩展

Burgers-Fisher是一维问题，但PINN换到二维甚至三维，代码改动量其实很小。网络输入从2维变成3维或4维，把 (x, y, z, t) 都拼进输入向量；PDE残差里的偏导数也换成对应的自动微分项。复杂区域比传统方法好处理得多，你只需要在区域内生成采样点，不需要生成结构化网格。

我建议下一个项目可以试试二维Burgers方程或者二维热方程。训练时会发现，维度提高后残差点数量要成倍增加，不然空间采样密度不够，预测曲面容易出现局部偏离。

5.2 反问题与参数识别

PINN最让我心动的一个用途是反问题。假设方程里的 (\nu) 或 (\beta) 未知，我们手里只有一些稀疏的观测数据，那就可以把未知系数设成可训练变量，和网络参数一起优化。损失函数里既包含PDE残差，也包含观测数据误差。这样训练完，不但能得到解场，还能把方程系数估计出来。

我做一个简单测试时，把真实的 (\nu=0.01) 藏起来，初始化成0.05，用100个观测点约束，最后网络把 (\nu) 收敛到了0.0107。这个精度不算高，但足以说明PINN结构上的反演能力。如果你有实验数据，想做参数辨识，这条路线很值得研究。

5.3 我的一点实际操作体会

如果你问我PINN能不能替代传统数值方法，我的态度是不太能，也没必要。传统方法在精度、效率和可靠性上仍然占优，尤其是有成熟网格工具的场景。但PINN作为补充，在处理复杂区域、逆问题、无法全量采样的场景时，确实有独特的价值。

我给刚开始接触PINN的朋友一个建议：不要拿完整版Burgers-Fisher方程当第一个练手项目，先跑热传导、再跑Burgers、最后加反应项，一步步把每个环节的坑都踩一遍。网络结构、自动微分、损失聚合、采样策略，这些模块单独拆开都不难，但拼在一起的时候，任何一个环节掉链子都会让整体训练失败。

这个项目做完之后，我最大的体会是：PINN的代码量比有限差分少很多，但“调试脑力”一点不少。物理理解越深入，损失函数设计越合理，训练成功率越高。如果你在复现过程中遇到奇怪的问题，可以回到第4章的速查表逐条排查，大概率能找到原因。