用Python从零实现PINN求解Burgers-Fisher方程全流程

物理信息神经网络（PINN）现在已经是科学计算圈绕不开的话题。我最早接触它是因为要解Burgers-Fisher方程——一个同时塞进了非线性对流、扩散和反应项的偏微分方程，传统有限差分做起来并不轻松。这篇文章用Python从零实现一套基于PINN的完整求解流程，包括网络设计、损失函数构造、训练策略和误差验证。想上手PINN、又正在找合适测试方程的读者，可以直接照着代码跑。

1. 这个方程为什么值得用神经网络重解一遍

1.1 方程结构与三项物理机制

Burgers-Fisher方程的标准形式写出来并不复杂：

[
\frac{\partial u}{\partial t} + \alpha u \frac{\partial u}{\partial x} - \beta \frac{\partial^2 u}{\partial x^2} = \gamma u (1 - u)
]

其中 (u) 是待求的标量场，(x) 是空间坐标，(t) 是时间，(\alpha)、(\beta)、(\gamma) 分别是控制方程行为的三组参数。初看它只是一个二阶非线性偏微分方程，但骨子里是三个物理过程的叠加。

第一项 (\partial u/\partial t) 是演化项，描述物理量随时间的变化。第二项 (\alpha u , \partial u/\partial x) 来自Burgers方程，是典型的非线性对流项，速度依赖 (u) 自身的大小，一旦幅值变大会出现波形变陡甚至间断。第三项 (\beta , \partial^2 u/\partial x^2) 是扩散项，负责抹平梯度、平滑波形。等式右侧的 (\gamma u(1-u)) 来自Fisher方程，是带上限的逻辑斯蒂反应项，表示种群或化学反应物在生长到上限1之前的自我增殖。

这三项组合起来，解既可能呈现陡峭的波前，又可能被扩散抹平，反应项还持续提供成长驱动力。对传统数值方法来说，对流项带来的陡峭梯度会让网格设计变得麻烦——波前位置随时间移动，你既想加密局部网格，又不知道加密区域该放在哪里。而PINN只需要用一组带物理约束的神经网络去逼近 (u(x,t))，不需要在空间上人工做任何网格规划。这是我选择这个方程作为PINN验证对象的首要原因。

1.2 参数如何改变解形态

参数的选择直接决定整个问题的难度，我在动手写代码前总是先把这个想清楚。三组参数的影响可以用下面这张表快速概括：

以 (\alpha=1, \beta=0.1, \gamma=1) 这一组为例，波前在 (x=0) 附近有一个跨越，过渡带大约只有2到3个单位长度。如果把 (\beta) 降到0.01，过渡带会更窄，神经网络需要更多内部采样点才能解析这个薄层，否则PDE残差损失会在波前附近剧烈波动。反过来，如果 (\beta) 放到1，整个解会平滑很多，同样的网络宽度就能覆盖更大的空间范围。所以，不要一上来盲目调代码，先定下一组目标参数、判断波前陡峭程度，这是很重要的一步前置分析。

1.3 行波解析解是天然的验证标尺

更妙的是，Burgers-Fisher方程存在形式简洁的行波解。设：

[
u(x,t) = \frac{1}{2}\left[1 - \tanh\left(k(x - ct)\right)\right]
]

把它代入原方程，通过对比系数可以推导出两个关系式：

[
k = \frac{\alpha}{4\beta},\qquad c = \frac{2\beta\gamma}{\alpha} + \frac{\alpha}{2}
]

以 (\alpha=1, \beta=0.1, \gamma=1) 为例，计算得到 (k=2.5)，(c=0.7)。这意味着在空间坐标 (x \in [-10, 10]) 的范围内，解的过渡带会从初始位置附近向 (x) 正方向移动；当 (t=1) 时，波前中心移动到 (x=0.7) 附近。

这个解析解非常重要，因为PINN训练完以后，我可以用它作为精确解的基准，计算预测解的L2相对误差，而不是仅仅看损失函数降了多少。损失函数是训练指标，解析解才是可信度指标，两者必须同时盯住。

2. 网络的"物理损失"设计：把PDE从约束变成目标

2.1 用自动微分替代差分格式

PINN的思路是把偏微分方程的求解转成一个优化问题。定义一个神经网络 (u_\theta(x,t)) 作为解的代理模型，(\theta) 是网络参数。我们希望这个网络输出在训练区域内始终满足三个条件：位于物理方程允许的解空间内、满足初始条件、满足边界条件。这三个条件被统一编码成损失函数的三个部分。

关键点在于怎么计算导数。传统方法需要在网格上做有限差分近似，而PINN直接利用自动微分，从网络输出 (u_\theta) 出发，对输入 (t) 和 (x) 求一阶、二阶偏导。在PyTorch里就是 torch.autograd.grad 的两次调用。第一次求出 (\partial u/\partial x)，第二次对 (\partial u/\partial x) 再求一次，得到 (\partial^2 u/\partial x^2)。这里必须设置 create_graph=True，否则第二次求导的梯度无法继续反向传播到网络参数上，PDE残差对参数的梯度链就断了。

2.2 三类损失项的权重分配

代码实现中，损失函数由三部分构成：

• PDE残差项：强制网络输出代入方程后残差为零，这是物理约束的核心；
• 初始条件项：在 (t=0) 的采样点上，约束网络输出逼近给定的 (u(0,x))；
• 边界条件项：在区域左右端点，约束网络输出逼近给定的边界值。

三者权重默认可以取1:1:1。但实际训练中，PDE残差项因为包含二阶导，量级常常和初边值项差异很大。权重失衡时，某个损失项会在总损失中占据绝对主导，其他约束被忽略。这种情况可以在训练中期动态调节权重，具体手段我在第6章会展开。

2.3 与有限差分法求解的底层差异

PINN与传统有限差分法有本质区别。有限差分法把连续PDE离散到网格节点上，每个节点上的 (u) 是一个未知变量，节点数越多，自由度越大，求解过程是解一个大型代数方程。PINN则是用一组连续函数去逼近解，自由度是网络参数的个数，求解过程是不断迭代减小损失。

PINN的优势在于无需网格生成，复杂几何边界也能通过配点方式处理；劣势是损失函数非凸，优化过程可能陷入局部最优，解的精度不像有限体积法那样有系统性误差估计框架。理解这两点，能帮你判断什么时候该上PINN，什么时候还是老老实实写传统格式。

3. 模型搭建中最容易出错的两个选择

3.1 激活函数为什么必须选tanh

几乎所有PINN的实现都会选tanh作为激活函数，这不是偶然。ReLU看起来简单高效，但它在正区间的一阶导数是常数，二阶导恒等于0。PDE残差里需要 (\partial^2 u/\partial x^2)，用ReLU构造的网络，二阶导直接归零，方程残差项变成了一个不包含二阶导的错误表达式，训练也彻底失去意义。我见过一个朋友用ReLU跑Burgers方程，损失一直不降，换了tanh之后立刻收敛，问题就在这个细节上。

tanh的优势有三个：处处光滑可导，二阶导非零；输出范围对称在 ((-1,1))，和归一化后的输入范围匹配自然；零附近梯度接近1，有利于反向传播。当然也有实验用swish、正弦或sigmoid的改进版本，但工程上tanh最省心，默认用它起步不会错。

3.2 网络宽度、深度与采样点数量的匹配

网络结构方面，Burgers-Fisher方程场景下我建议使用 [2, 50, 50, 50, 1] 这类中等规模结构，输入层2个神经元对应 (x) 和 (t)，输出层1个神经元对应 (u)，中间3层每层50个神经元。为什么不是越深越好？PINN的残差损失需要把二阶导的梯度一路回传，网络深度增加会让梯度信号衰减得更剧烈。宽度50对这个方程已经够用，平滑行波解不需要超大容量。

采样点数量影响更直接。内部采样点一般取5000到10000个，初始条件采样点取200到400个，边界条件采样点取100到200个。如果波前很陡，也就是 (\beta) 值很小，内部点建议多取，否则波前区域残差很大而采样点稀疏，损失计算无法反映真实误差分布。随机均匀采样是最稳妥的做法，想提升采样效率也可以试试拉丁超立方采样。

4. 完整代码结构与关键实现细节

4.1 环境清单与全局配置

需要先装齐依赖：torch>=1.13、numpy、matplotlib。还没装PyTorch的话，直接运行 pip install torch 就能搞定。这里用PyTorch而不是TensorFlow，原因是自动求导接口更直接，写出自定义损失函数时理解成本低很多。

python复制import torch
import numpy as np

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 方程参数
alpha = 1.0
beta = 0.1
gamma = 1.0

# 求解区域
x_range = [-10.0, 10.0]
t_range = [0.0, 1.0]

如果电脑没有GPU，全靠CPU训练这个规模的网络完全可行，迭代几千步，时间也就几分钟级别。

4.2 网络定义、自动求导与损失函数

先定义网络类。这个类非常简单，除了标准的多层全连接结构，注意tanh激活函数不要漏掉。

python复制class PINN(torch.nn.Module):
    def __init__(self, layers=[2, 50, 50, 50, 1]):
        super().__init__()
        self.layers = layers
        self.activation = torch.nn.Tanh()
        self.linears = torch.nn.ModuleList()
        for i in range(len(layers) - 1):
            self.linears.append(torch.nn.Linear(layers[i], layers[i + 1]))

    def forward(self, x, t):
        z = torch.cat([x, t], dim=1)
        for linear in self.linears[:-1]:
            z = self.activation(linear(z))
        z = self.linears[-1](z)
        return z

接下来是通用导数计算函数。这是整个PINN最核心的部分，注意两个细节：输入 (x) 和 (t) 要设置 requires_grad_，第二次求梯度时 create_graph=True 必须保留。

python复制def pde_residual(model, x, t):
    x.requires_grad_(True)
    t.requires_grad_(True)

    u = model(x, t)

    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]
    u_t = torch.autograd.grad(u, t, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]

    f = u_t + alpha * u * u_x - beta * u_xx - gamma * u * (1 - u)
    return f

调用 grad 时传入 grad_outputs=torch.ones_like(u) 是因为 torch.autograd.grad 默认要求输出是标量，如果我们对批量向量直接求导，必须显式给一个和输出同形状的梯度向量。这个细节新手很容易踩。

损失函数封装成函数，返回三项损失之和。

python复制def compute_loss(model, x_r, t_r, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc):
    f = pde_residual(model, x_r, t_r)
    loss_pde = torch.mean(f ** 2)

    u_pred_ic = model(x_ic, t_ic)
    loss_ic = torch.mean((u_pred_ic - u_ic) ** 2)

    u_pred_bc = model(x_bc, t_bc)
    loss_bc = torch.mean((u_pred_bc - u_bc) ** 2)

    return loss_pde + loss_ic + loss_bc

4.3 采样与数据准备

采样策略直接决定训练结果。内部点用 torch.rand 生成均匀随机数再映射到对应区间；初始点在 (t=0) 处采样，(x) 覆盖整个空间；边界点取左右两端，时间维度覆盖整个时间范围。这里用的参数是 (\alpha=1, \beta=0.1, \gamma=1)，初始解由解析解给出。

python复制n_r, n_ic, n_bc = 8000, 300, 200

# 内部残差点
x_r = torch.rand(n_r, 1, device=device) * (x_range[1] - x_range[0]) + x_range[0]
t_r = torch.rand(n_r, 1, device=device) * (t_range[1] - t_range[0]) + t_range[0]

# 初始条件采样：t=0, 解析解 u(0,x) = 0.5*(1 - tanh(2.5x))
x_ic = torch.rand(n_ic, 1, device=device) * (x_range[1] - x_range[0]) + x_range[0]
t_ic = torch.zeros_like(x_ic)
u_ic = 0.5 * (1 - torch.tanh(2.5 * x_ic))

# 边界采样：x=-10 和 x=10 各一半
x_bc = torch.cat([
    torch.full((n_bc // 2, 1), x_range[0], device=device),
    torch.full((n_bc - n_bc // 2, 1), x_range[1], device=device)
], dim=0)
t_bc = torch.rand(n_bc, 1, device=device) * (t_range[1] - t_range[0]) + t_range[0]

# 边界值：x=-10处接近1, x=10处接近0，解析解在这两点的残差在1e-10量级，可忽略
u_bc = torch.cat([
    torch.ones(n_bc // 2, 1, device=device),
    torch.zeros(n_bc - n_bc // 2, 1, device=device)
], dim=0)

4.4 训练循环与两阶段优化策略

PINN的标准训练方式是两阶段：先用Adam把各损失压到同一量级，再用L-BFGS做高精度收敛。Adam并行能力强、不容易爆炸，适合训练初期大范围探索；L-BFGS利用二阶曲率信息，在接近最优解时收敛速度远快于Adam。

python复制model = PINN().to(device)
optimizer_adam = torch.optim.Adam(model.parameters(), lr=1e-3)

def train_adam(steps=2000):
    model.train()
    for step in range(steps):
        optimizer_adam.zero_grad()
        loss = compute_loss(model, x_r, t_r, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc)
        loss.backward()
        optimizer_adam.step()
        if step % 500 == 0:
            print(f"Adam step {step}, loss={loss.item():.6e}")

train_adam(2000)

Adam阶段结束后切换到L-BFGS。L-BFGS的接口要求把损失函数封装成闭包，每次step前先清零梯度，再把闭包返回的损失交给优化器。

python复制optimizer_lbfgs = torch.optim.LBFGS(model.parameters(), max_iter=500, history_size=50)

def closure():
    optimizer_lbfgs.zero_grad()
    loss = compute_loss(model, x_r, t_r, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc)
    loss.backward()
    return loss

optimizer_lbfgs.step(closure)

在真实项目里，我会把Adam的2000步和L-BFGS的500步组合起来。训练完成后，保存 model.state_dict()，便于后续验证和可视化。

4.5 验证与误差统计

验证阶段把预测值和解析解做对比。解析解的形式是：

[
u_{\text{analytic}}(x,t) = 0.5 \left[1 - \tanh\left(2.5(x - 0.7t)\right)\right]
]

计算L2相对误差的代码如下：

python复制x_test = torch.linspace(x_range[0], x_range[1], 400, device=device).reshape(-1, 1)
t_test = torch.full_like(x_test, 0.5)  # 取 t=0.5 时刻检验

u_pred = model(x_test, t_test).detach()
u_analytic = 0.5 * (1 - torch.tanh(2.5 * (x_test - 0.7 * t_test)))

rel_err = torch.norm(u_pred - u_analytic) / torch.norm(u_analytic)
print(f"t=0.5时的L2相对误差: {rel_err.item():.6e}")

这一步非常重要。很多人只看损失函数降下来了就认为训练成功，但损失下降只能说明约束被满足了，不代表解真的逼近真实物理场，两件事必须分开验证。

5. 一次真实训练过程复盘：收敛曲线与结果检验

5.1 损失曲线分阶段解读

以我实际跑过的训练过程为例。Adam阶段前500步，PDE损失通常从几十量级迅速降到 (10^{-2}) 附近，因为网络参数随机初始化时残差很大，梯度方向比较一致，下降很快。500到2000步，损失缓慢下降到 (10^{-3}) 到 (10^{-4}) 之间，这个阶段收敛速度明显变慢，因为剩下的都是精细调整。切到L-BFGS后，损失通常能进一步压到 (10^{-5}) 甚至更低。

如果你的损失在第一次快速下降后长时间不动，问题通常不在优化器，而在采样点覆盖或激活函数设置。另一个常见原因是没有把输入归一化到合适范围，(x) 从-10到10、(t) 从0到1，尺度差异会给优化带来额外负担。

5.2 解的形态与行波解析解对比

训练完成后，取 (t=0.25)、(0.5)、(0.75) 三个时刻，分别画出预测解和解析解的曲线对比。正常情况下，预测曲线应该和解析解几乎重合，波前位置随 (t) 增大向右移动，过渡带形态保持一致。

波前处往往是误差最大的区域，因为那里梯度最陡，神经网络逼近局部高梯度区域时需要更多采样点。如果发现某个时刻波前预测位置偏差明显，大概率是采样点数量不足，或者Adam阶段迭代次数不够。可以把训练那一段的网格画出来，配合损失曲线一起诊断。

5.3 相对L2误差怎么算才可信

L2相对误差计算公式是：在检验网格上所有预测解和解析解差值的二范数，除以解析解的二范数。要让这个误差指标可信，检验网格必须避开训练采样点，用均匀的 linspace 生成，而不是直接拿训练数据算。检验时刻也应选多个，建议在 (t=0.25, 0.5, 0.75) 分别计算，做成一张表：

这个量级是我在 (\alpha=1, \beta=0.1, \gamma=1) 参数下得到的典型结果。如果你的误差在 (10^{-2}) 量级，优先增加内部采样点数量，再考虑增加L-BFGS迭代次数。

6. 踩坑记录：五个根源性问题的排查思路

6.1 二阶导灾难：激活函数的陷阱

ReLU导致二阶导数恒为零，网络退化成一个只能表达分段线性函数的近似器，PDE残差项完全失真。诊断方法很简单：打印一次 pde_residual 的输出，如果发现所有样本的残差几乎为常数且不随训练下降，第一件事就是检查激活函数。

换成tanh能解决99%的这类问题。这里顺便提醒，如果以后用更高阶的方程，比如三阶导，tanh同样适用，只是要确保足够的网络宽度来稳定高阶导数的传播。

6.2 采样点数量与分布不均

均匀随机采样在大部分情况下够用，但如果波前过渡带很窄，随机点在波前处的密度可能不足，导致损失计算低估波前区域的误差。一个实用的改进是残差引导采样：先训练几百步，统计每个候选采样点的残差绝对值，找出残差最大的区域，在这些区域附近补充采样点。

python复制# 残差引导采样示意：计算候选点残差，选出残差最大的点位并追加到训练集
candidate_x