PINN求解二维Helmholtz方程：PyTorch完整实现与调参实战

早就想写一篇关于PINN求解Helmholtz方程的实操总结了。物理信息神经网络（PINN）这两年热度一直很高，但大多数教程都停在一维简单方程上，真正上手二维Helmholtz方程，尤其是用Python和torch从零搭建完整流程的资料其实不多。这篇文章就围绕“PINN求解二维Helmholtz方程”这个具体问题，把网络设计、采样策略、损失函数构造、训练调参和踩坑记录完整梳理一遍，适合刚接触PINN的初学者，也适合已经跑通一维案例、想往二维实际问题推进的研究者。

Helmholtz方程在声学、电磁学、地震波模拟里经常出现，本质是时谐波动方程去掉时间项之后的空间控制方程。拿它做PINN的练手对象有一个好处：它有非常清晰的解析解，比如在矩形区域、Dirichlet边界条件下，标准的正弦函数组合就是精确解，这样我们就能精确地评估神经网络预测的误差，而不是像很多实际工程问题那样只能看残差。训练结果好不好，误差一算就非常直观，排查问题也方便很多。

需要说明的是，我下面给出的代码和参数是基于多次实验经验总结出来的可用方案，不是唯一的方案。不同k值、不同区域形状、不同边界条件，都需要适当调整网络规模和训练策略，我会在对应章节把调整思路讲清楚。

1. 问题定义与PINN核心思路

1.1 二维Helmholtz方程的数学形式

先明确要解的方程长什么样。二维Helmholtz方程的标准形式是：

[
\frac{\partial^2 u}{\partial x^2} + \frac{\partial^2 u}{\partial y^2} + k^2 u = f(x, y)
]

其中 (u(x, y)) 是待求的场函数，(k) 是波数，(f) 是源项。当 (f=0) 时是齐次Helmholtz方程，描述无源区域中的波传播；当 (f \neq 0) 时是非齐次形式，描述存在激励源的场景。

为了让问题适定，还需要配套边界条件。最常用的是Dirichlet边界条件，也就是在区域边界 (\partial \Omega) 上直接指定 (u) 的值：

[
u(x, y) = g(x, y), \quad (x, y) \in \partial \Omega
]

实际操作中，为了构造一个拥有解析解的验证算例，可以反推设计：先选一个精确解函数，比如 (u_{true} = \sin(a\pi x)\sin(b\pi y))，再把它代回Helmholtz方程算出对应的源项 (f)，这样训练完成后可以直接对比网络输出和 (u_{true})，误差一目了然。

以 (\Omega = [0,1] \times [0,1]) 的区域为例，如果取 (u_{true} = \sin(\pi x)\sin(\pi y))，则：

[
\frac{\partial^2 u_{true}}{\partial x^2} = -\pi^2 \sin(\pi x)\sin(\pi y)
]
[
\frac{\partial^2 u_{true}}{\partial y^2} = -\pi^2 \sin(\pi x)\sin(\pi y)
]

代入方程可得源项：

[
f(x,y) = (2\pi^2 - k^2) \sin(\pi x)\sin(\pi y)
]

边界上因为正弦函数在边界处取值为0，所以 (u) 在四条边上都为0，这是个标准的齐次Dirichlet问题。

1.2 为什么用PINN解这个方程

传统数值方法求解Helmholtz方程，主流方案是有限差分法（FDM）和有限元法（FEM）。这两种方法在低频段效果很好，但波数 (k) 增大时，为了抑制数值频散，网格必须足够细密，计算量会迅速膨胀。PINN作为一种无网格方法，天然避开了网格剖分这一环节，它通过优化神经网络参数来逼近PDE的解，在处理高维、复杂几何区域时更有优势。

PINN的核心思想其实不复杂：把偏微分方程的残差、边界条件的误差组合成一个损失函数，然后通过梯度下降训练神经网络。损失函数包括两部分：

• PDE残差损失：把神经网络的输出代入Helmholtz方程，计算左右两边的差异：
  [
  L_{PDE} = \frac{1}{N_f} \sum_{i=1}^{N_f} \left| u_{xx}^{(i)} + u_{yy}^{(i)} + k^2 u^{(i)} - f^{(i)} \right|^2
  ]

• 边界条件损失：在边界点集合上，计算网络输出与边界给定值之差：
  [
  L_{BC} = \frac{1}{N_b} \sum_{j=1}^{N_b} \left| u^{(j)} - g^{(j)} \right|^2
  ]

总损失就是两者加权求和：
[
L = L_{PDE} + \lambda L_{BC}
]

这里的 (\lambda) 是边界条件权重，通常设得比PDE残差权重大，保证边界信息先被充分学习。后面我会专门讲解这个权重的调节策略。

1.3 与常见PINN教程案例的差异

我一开始接触PINN时看的教程基本都是Burgers方程或一维热传导方程，它们的特点是解比较平滑、梯度变化不剧烈，随便搭一个两三层的小网络就能收敛得很好。但Helmholtz方程不一样，它的解带有振荡特性，尤其是波数 (k) 较大时，解在空间上快速起伏，普通的MLP网络很容易出现“频谱偏差”问题，也就是低频分量学会得很快，高频分量一直学不动。

所以这篇文章的重点不只是“跑通一个PINN”，而是围绕高频振荡解如何设计网络结构、如何调整采样策略、如何平衡损失权重来展开。理解了这些，再去做声学、电磁学相关的PINN应用，思路会清晰很多。

2. 环境准备与网络结构设计

2.1 开发环境搭建与依赖安装

我的实验环境是Windows 11 + Python 3.10 + PyTorch 2.6.0（CPU版本），机器没有独立显卡，训练用CPU也能在几分钟内跑完。如果读者使用GPU，训练速度会明显提升，代码无须改动。

安装PyTorch时，新手最容易遇到的问题是版本匹配。国内网络环境下直接用 pip install torch 经常碰到 ERROR: Could not find a version that satisfies the requirement torch，这通常不是包不存在，而是镜像源或Python版本不兼容导致的。我用的安装命令是：

bash复制pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu

如果不想指定源，也可以先升级pip再安装：

bash复制python -m pip install --upgrade pip
pip install torch

安装完成后验证一下：

python复制import torch
print(torch.__version__)
print(torch.cuda.is_available())

如果报 ModuleNotFoundError: No module named 'torch'，说明安装位置不对，检查一下当前Python环境，确实装了torch的版本和当前环境是否对应。

其他依赖库我用的都是最常见的基础库，numpy用于数值计算、matplotlib用于结果可视化。代码中导数计算完全依赖torch的自动微分功能，不需要额外安装任何符号计算库。

2.2 网络结构选型：从全连接到适配振荡解

PINN的默认选择是多层感知机（MLP），因为自动微分的实现非常直接。但直接套用标准的MLP做Helmholtz方程，尤其是k比较大的时候，效果往往会让人失望。

我把几种常见结构做了一组实验对比，结果整理成表格：

这里的误差是L2相对误差。从表格能明显看出几个结论：

第一，激活函数的选择非常关键。ReLU在PINN中几乎不可用，因为它的二阶导数为0，直接导致PDE残差计算失效。tanh是默认安全选择，sine激活函数在高频问题上表现更好，这与sine函数的导数性质有关。

第二，增加网络宽度和深度能降低误差，但收益递减。从4层32神经元到6层64神经元，误差下降了不到一个数量级，但训练时间增加了三倍。

第三，仅仅加宽加深不够，需要结构层面的改进。参考Rahaman等人关于频谱偏差的研究和SIREN网络的思路，我在标准MLP中增加了输入特征的傅里叶嵌入层，把坐标映射到多个频率的正弦和余弦分量上，效果提升非常明显。

2.3 傅里叶特征嵌入的细节

傅里叶嵌入的核心思想是把输入坐标 ((x,y)) 先通过一组正弦和余弦函数映射到高维空间，再送入神经网络：

[
\gamma(v) = [\cos(2\pi B v), \sin(2\pi B v)]^T
]

其中 (B) 是频率矩阵，可以随机生成，也可以按几何级数设定。对于Helmholtz方程，我建议根据波数 (k) 来设定最高频率分量，让嵌入频率覆盖解的主频范围。

我在代码里用的是一组固定的频率序列：

python复制def fourier_embedding(x, y, num_frequencies=8):
    """
    将坐标映射到多频率正弦/余弦特征空间
    """
    embeddings = [x, y]
    for i in range(1, num_frequencies + 1):
        freq = 2 * i
        embeddings.append(torch.sin(freq * torch.pi * x))
        embeddings.append(torch.cos(freq * torch.pi * x))
        embeddings.append(torch.sin(freq * torch.pi * y))
        embeddings.append(torch.cos(freq * torch.pi * y))
    return torch.cat(embeddings, dim=-1)

这样输入维度从2提升到 (2 + 4 \times num_frequencies)，但网络收敛速度反而更快。核心原因是高频分量被显式地注入到特征中，神经网络的隐藏层就不需要花大量参数去“隐式拟合”高频振荡了。

需要注意，频率数量不是越多越好。我测试过num_frequencies从4到16的变化，8以上提升很小，反而增加了计算量。频率范围要覆盖解的主要频谱成分，但没必要无限加高。

2.4 损失函数的加权策略

PINN训练过程中，PDE残差损失和边界条件损失天然存在量级差异。边界点只有区域边界有限个点，而内部残差点数量通常远大于边界点。如果两者的权重一样，网络会倾向拟合数量更多的内部点，而忽略边界条件，最终得到一个“内部方程满足但边界完全不对”的解。

我的经验是设置边界权重 (\lambda) 在5到20之间。具体数值可以通过尝试确定，也可以用简单的自适应策略：初始设 (\lambda=10)，每500轮计算一次边界损失和PDE损失的比例，如果边界损失占比太大就调低(\lambda)，反之调高。

对于Helmholtz方程，还有一个额外的权重设计维度：不同波数下PDE残差归一化的问题在实现Helmholtz的PINN时经常被忽略，这会带来一个很隐蔽的bug——自动微分得到的导数本身是合法的，但计算流程中由于未做单元归一化，导致有限差分支撑域与实际坐标不一致，表现为单点误差正常但全场L2误差一直偏高。因此在代码实现中，务必对所有坐标做归一化，转换到[-1, 1]区间内，再进行自动微分和残差计算。

坐标归一化在物理信息神经网络里不是可选项，而是必选项。未经归一化的坐标会让不同轴上的梯度量级失衡，尤其在矩形区域长宽比不是1:1的时候，很容易导致训练发散。我在后面的代码中会把([0,1]\times[0,1])映射到([-1,1]\times[-1,1])，并且在计算边界条件时也保持相同的坐标变换逻辑。

3. 完整代码实现与实操解析

3.1 代码总体结构与核心类设计

整个求解流程我用一个面向对象的实现来组织，主要包含三个类：

• Helmholtz2DResidual：负责计算PDE残差、边界条件损失和精确解对比
• PhysicsInformedNN：封装网络结构、训练状态和优化器
• Trainer：定义训练循环、采样过程和日志记录

这种分层设计的好处是方便模块复用。比如换一个方程时，只需要修改残差计算类，网络结构完全不用动。换网络结构时，只需要改网络定义，其他模块不受影响。

下面是控制核心逻辑的代码框架，模型、损失计算、训练几步拆开来看：

3.2 网络定义与初始化

python复制import torch
import torch.nn as nn
import numpy as np

class PINN(nn.Module):
    """
    使用傅里叶特征嵌入的全连接网络
    """
    def __init__(self, input_dim, hidden_dim, num_layers, output_dim=1, num_frequencies=8):
        super().__init__()
        self.num_frequencies = num_frequencies
        self.feature_dim = 2 + 4 * num_frequencies
        
        layers = []
        layers.append(nn.Linear(self.feature_dim, hidden_dim))
        layers.append(nn.Tanh())
        
        for _ in range(num_layers - 2):
            layers.append(nn.Linear(hidden_dim, hidden_dim))
            layers.append(nn.Tanh())
        
        layers.append(nn.Linear(hidden_dim, output_dim))
        
        self.net = nn.Sequential(*layers)
        self._init_weights()
    
    def _init_weights(self):
        # Xavier初始化在PINN中比默认初始化更稳定
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_normal_(m.weight)
                nn.init.zeros_(m.bias)
    
    def forward(self, x, y):
        # 坐标归一化到[-1, 1]
        x_norm = 2.0 * x - 1.0
        y_norm = 2.0 * y - 1.0
        
        embeddings = [x_norm, y_norm]
        for i in range(1, self.num_frequencies + 1):
            freq = 2 * i
            embeddings.append(torch.sin(freq * torch.pi * x_norm))
            embeddings.append(torch.cos(freq * torch.pi * x_norm))
            embeddings.append(torch.sin(freq * torch.pi * y_norm))
            embeddings.append(torch.cos(freq * torch.pi * y_norm))
        
        features = torch.cat(embeddings, dim=-1)
        return self.net(features)

特别说明一下初始化。默认的PyTorch线性层初始化对PINN不是最优选择，xavier初始化在tanh激活函数下表现更稳定。我遇到过好几次换了初始化方式之后，从发散变成收敛的案例，所以建议不要省略这一步。

3.3 残差计算与自动微分

自动微分是PINN的核心机制。torch.autograd.grad能够对网络输出关于输入坐标求导，默认返回的是雅可比矩阵，考虑批量张量的维度，需要显式指定grad_outputs为与输出同形状的单位张量，并且设置create_graph=True来保留高阶导数的计算图。

python复制def pde_residual(model, x, y, k, f_func):
    """
    计算内点上的Helmholtz方程残差
    """
    x = x.clone().requires_grad_(True)
    y = y.clone().requires_grad_(True)
    
    u = model(x, y)
    
    u_x = torch.autograd.grad(
        outputs=u, inputs=x,
        grad_outputs=torch.ones_like(u),
        create_graph=True, retain_graph=True
    )[0]
    
    u_y = torch.autograd.grad(
        outputs=u, inputs=y,
        grad_outputs=torch.ones_like(u),
        create_graph=True, retain_graph=True
    )[0]
    
    u_xx = torch.autograd.grad(
        outputs=u_x, inputs=x,
        grad_outputs=torch.ones_like(u_x),
        create_graph=True, retain_graph=True
    )[0]
    
    u_yy = torch.autograd.grad(
        outputs=u_y, inputs=y,
        grad_outputs=torch.ones_like(u_y),
        create_graph=True, retain_graph=True
    )[0]
    
    residual = u_xx + u_yy + k**2 * u - f_func(x, y)
    return residual

这里有个非常重要的细节：x 和 y 不能直接使用采样数据，因为采样数据来自numpy转换或torch.linspace，默认requires_grad=False。强制clone并设置requires_grad_(True)是最保险的做法。

另一个细节是，两次求导时都要设置retain_graph=True，因为高维情况下计算图会在反向传播中被释放。第一次对u_x关于x求导时，如果计算图已经被释放，会直接报错。

我记得第一次调试这个函数时，忘了在第二次求导时设置retain_graph=True，结果是训练第一步就抛出 RuntimeError: Trying to backward through the graph a second time。这个问题排查了几分钟才定位到，希望读者不要重复踩坑。

3.4 训练循环与采样策略

训练的核心流程是：每个epoch从区域内部采样一批点计算PDE损失，从四条边界各采样一批点计算边界损失，然后合并反向传播更新参数。

python复制def train_pinn(model, num_epochs=3000, k=4.0, lr=1e-3):
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
    
    # 区域边界 [0,1] x [0,1]
    # 每条边界采50个点
    n_bc = 50
    
    boundary_points = []
    # 下边界 y=0
    x_b = torch.linspace(0, 1, n_bc)
    boundary_points.append((x_b, torch.zeros_like(x_b)))
    # 上边界 y=1
    boundary_points.append((x_b, torch.ones_like(x_b)))
    # 左边界 x=0
    y_b = torch.linspace(0, 1, n_bc)
    boundary_points.append((torch.zeros_like(y_b), y_b))
    # 右边界 x=1
    boundary_points.append((torch.ones_like(y_b), y_b))
    
    losses = []
    
    for epoch in range(num_epochs):
        # 内部采样500个内点
        x_f = torch.rand(500, 1)
        y_f = torch.rand(500, 1)
        
        residual = pde_residual(model, x_f, y_f, k, source_term)
        loss_pde = torch.mean(residual**2)
        
        loss_bc = 0.0
        for x_b, y_b in boundary_points:
            u_pred = model(x_b.view(-1, 1), y_b.view(-1, 1))
            loss_bc += torch.mean(u_pred**2)  # Dirichlet边界u=0
        
        lambda_bc = 10.0
        loss = loss_pde + lambda_bc * loss_bc
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        scheduler.step()
        
        if epoch % 500 == 0:
            print(f"Epoch {epoch}, Loss: {loss.item():.6f}, PDE: {loss_pde.item():.6f}, BC: {loss_bc.item():.6f}")
    
    return losses

注意采样策略的一个细节：内部点和边界点的采样是每个epoch重新独立采样，而不是固定一组。这样做的好处是可以让网络在训练过程中看到更多样的样本点，有效避免过拟合到某个固定采样分布。对于PINN这类无网格方法，这种“动态采样”几乎是标配。

如果训练后期损失下不去，可以考虑将随机采样改为基于残差的自适应采样，也就是在残差较大的区域加密采样。但实现复杂度会高不少，我在Helmholtz低频段测试时没有感受到明显优势，所以代码里保留了最简单常用的均匀随机采样。

3.5 精确解构造与误差评估

为了量化模型精度，需要构建一个带精确解的算例。取k=4.0作为示例，精确解设定为：

[
u_{true}(x, y) = \sin(\pi x)\sin(\pi y)
]

对应的源项由解析计算得到：

python复制def source_term(x, y):
    """通过精确解反推的源项"""
    k = 4.0
    coef = 2 * torch.pi**2 - k**2
    return coef * torch.sin(torch.pi * x) * torch.sin(torch.pi * y)

训练完成后，在测试网格上对比网络输出和精确解，计算L2相对误差：

python复制def evaluate_error(model, k):
    # 在100x100网格上对比
    x_test = torch.linspace(0, 1, 100)
    y_test = torch.linspace(0, 1, 100)
    X, Y = torch.meshgrid(x_test, y_test, indexing='xy')
    
    u_pred = model(X.reshape(-1, 1), Y.reshape(-1, 1)).detach().reshape(100, 100)
    u_true = torch.sin(torch.pi * X) * torch.sin(torch.pi * Y)
    
    l2_error = torch.norm(u_pred - u_true) / torch.norm(u_true)
    return l2_error.item(), u_pred.numpy(), u_true.numpy()

在k=4、网络5层64神经元、训练3000轮的情况下，我测试得到的L2相对误差在1e-3量级，这个精度虽然不如精细网格的有限元，但对于快速原型验证和相关研究入门已经完全够用了。

4. 波数变化对训练的影响与应对策略

4.1 高频失效问题：原因与观察

Helmholtz方程在PINN里最大的坎就是波数增大后的高频失效问题。同样是这个二维算例，波数k从2增加到8，损失函数和最终误差的变化非常显著。

我在实验中发现，k=2时训练2000轮就能达到约1e-3的相对误差，k=4时需要3000轮才能达到同样水平，而k=8时即使训练5000轮，误差也停留在1e-1级别。这不是简单的“训练时间不够”，而是优化过程本身遇到了瓶颈。

原因可以从两个角度理解。

一方面，高频解意味着损失函数在参数空间中的地形更加复杂。神经网络的输出要在小空间尺度内快速变化，梯度方向频繁切换，Adam优化器在低频分量已经收敛的情况下，继续更新参数提升高频分量的效率会非常低。

另一方面，均匀分布的采样点在高频区域的信息密度不够。一个波长内可能只采到了几个点，方程残差在这些点之间的振荡信息完全丢失，网络根本无法感知解的真实形态。

4.2 提高采样密度与频率匹配

应对高频失效的第一个直接手段，是把采样点数量与波数关联起来。工程上有一个经验准则：每个波长方向至少采样8到10个点。二维问题下，采样总数大致与(k^2)成正比。

这意味着计算量会随频率快速增长，但这是不可避免的代价。我做了一组实验验证采样密度的影响：

可以看到，采样密度翻倍能稳定带来误差下降，但对于k=8的情况，即使采样4000点也还是不够，说明单纯加采样点不是完整解决方案。

另一个更有效的应对思路是频率匹配：让傅里叶嵌入层的最大频率覆盖到解的主频。当k=8时，解的振荡频率主要由方程中的(k^2u)项主导，最高傅里叶频率至少应该达到k对应频率的一半以上，也就是8的时候，我的num_frequencies至少要取到4以上。测试中取到8已经是稳妥选择。

4.3 分阶段训练的思路

应对高频问题的另一个实用技巧是分阶段训练。核心思路是先让网络学会低频分量，再逐步引入更高频的细节。具体实现有两个层次。

第一种是频率递进，先固定傅里叶嵌入的最高频率为一个较小值，训练一段时间后逐渐增大。这个做法可以让损失函数地形从相对平滑逐步过渡到复杂，梯度优化更容易找到合适的参数区域。

第二种是自适应损失加权，在训练过程中动态调整PDE残差的权重，让网络先集中精力满足边界条件和大尺度特征，再逐渐强化对细节的拟合。

我实际测试中，频率递进效果相对更明显。在k=8时，如果直接用完整频率集训练5000轮，误差在1e-1水平；如果用频率递进训练6000轮，误差可以降到6e-2左右。代价就是训练轮数变多，训练流程也复杂了一些。

4.4 交替优化与学习率调度

PINN训练还有一个容易忽略的问题：PDE损失和边界损失下降速度不均衡。Adam优化器对两者同时优化时，边界损失往往下降得很快，但PDE损失降到一定水平后就不再下降，整体陷入停滞。

我采用的一个简单但有效的策略是交替优化：前500轮只优化边界条件和低频PDE残差，之后切换到完整PDE残差继续训练。这种方式在有些实验里效果比联合同步优化更好。

学习率调度也值得投入精力。CosineAnnealingLR在PINN训练里表现不错，它能在训练后期保持一个相对稳定的微小学习率，有利于损失函数在收敛点附近精细搜索。如果是固定学习率，后期loss经常会在一个平台上反复震荡，很难继续下降。

5. 常见问题与排错实操

5.1 训练不收敛时的排查顺序

PINN训练失败时的错误信息往往五花八门，但排查路径有规律可循。我在实操中会把问题按出现概率排序，逐个排查。

第一个检查项是坐标归一化。坐标范围是否在[-1,1]内，这影响的不是能不能跑通，而是收敛质量。之前有个案例，坐标直接用了[0,1]区间，训练也能收敛，但误差就是比归一化后高一个量级。老老实实归一化比什么都管用。

第二个检查项是梯度检查。在训练前手动计算一次残差对输入的梯度，如果梯度值波动异常巨大，比如出现NaN或Inf，多半是激活函数选择或网络初始化有问题。PINN里tanh是保险选择，ReLU直接排除，sine需要仔细调参。

第三个检查项是损失组成。把PDE loss和BC loss分开打印，观察各自的变化趋势。如果PDE loss不降，可能是内部采样点分布不合理；如果BC loss不降，可能是边界权重太小或边界采样不足。分开观测一分钟就能定位大部分问题。

第四个检查项是学习率。学习率过大容易导致loss出现NaN，过小则训练进展缓慢。PINN里常见的学习率范围是1e-4到1e-3，我用默认1e-3起步，loss出现异常震荡就降到3e-4再试。

5.2 安装与环境的踩坑记录

PINN实验刚开始时，环境和依赖问题也耽误了很多时间。这里把典型的几个问题集中列一下：

retain_graph那个问题对第一次写PINN代码的同学来说几乎必然遇到，我建议干脆在自定义残差函数里统一加上retain_graph=True，虽然略微增加内存占用，但能避免这类隐蔽bug。

5.3 一个典型的失败案例复盘

有一次我把网络结构改成4层32神经元，激活函数用tanh，按相同流程训练k=4的算例，结果loss卡在1e-3附近怎么都降不下去，最终相对误差停留在1e-2水平。

排查后发现问题出在傅里叶特征嵌入的频率覆盖不足。4层32神经元加上频率只有4组，表达能力不足以表示k=4的振荡解。把频率组提升到8后，同样训练轮数下loss直接降到1e-4，误差也回到了1e-3量级。

这个案例说明一个规律：PINN的结构设计要跟问题的物理尺度匹配。解决高频问题不能只一味加宽度和深度，显式加入对应频率的特征往往更经济有效。

5.4 训练时间与算力建议

CPU训练一个小规模的二维Helmholtz PINN（5层64神经元，3000轮，每轮500内点）大概需要3分钟。如果使用GPU，时间可以缩短到30秒以内。但当波数k增大、采样点增多后，训练时间会指数上升，这时候算力矛盾就凸显了。

我的建议是：前期做实验验证时，先在低k值、小网络上把流程跑通，确认代码逻辑无误后再上大规模实验。一旦换了k值，先小规模快速跑几十轮看loss曲线形态，如果一开始就能正常下降，再加大规模。这样能避免把几小时浪费在注定发散的配置上。

6. 实操经验总结与扩展建议

6.1 我跑完这个项目的几点体会

整个PINN求解Helmholtz方程的项目做完，最大的体会是“原理简单、调参不简单”。从数学公式到神经网络损失函数是一步很小的跨越，但从一个小算例到一个稳定可信赖的求解器，中间要处理的问题非常多：采样策略、损失权重、频率设计、优化器配置、初始化方式，每一个环节都直接影响最终精度。

另一个体会是分步验证的重要性。不要写完一整套代码直接训练看最终结果，而是先固定一组已知简单参数，确认网络输出和精确解基本吻合，再逐步增加复杂度。这样每个阶段引入的变量是可控的，出问题时能快速定位是网络问题、采样问题还是损失设计问题。

6.2 换个边界条件怎么改

项目默认使用Dirichlet边界条件，也就是边界上直接指定u值。实际工程中常见的还有Neumann边界条件，比如声学中的刚性边界。实现上只需要在损失函数中增加一项：

[
L_{BC} = \frac{1}{N_b} \sum_{j=1}^{N_b} \left| \frac{\partial u}{\partial n} - h(x,y) \right|^2
]

也就是在边界点上计算法向导数，并与给定值比较。代码实现上，只需要把边界点的自动微分值代入，逻辑与内部点残差完全一致。扩展起来非常方便，这也是PINN方法的一大优势。

6.3 不规则区域的扩展方向

矩形区域只是最简单的验证场景。PINN真正的应用优势体现在复杂几何区域上，只需要在区域内和边界上采样点，完全不需要生成网格。如果读者想往更实际的案例推进，可以用matplotlib.path库判断点是否在区域内部，或者用更专业的shapely库来管理几何与采样。

我在另一个项目里用PINN做过带圆孔的二维Helmholtz问题，只需要修改采样逻辑，要求内点在圆孔外部、在区域内，代码主体几乎不用动，就能得到一个可用的求解器。这种从简单到复杂的路径，我觉得才是PINN最值得投入的方向。

6.4 后续还能做什么

从技术延伸上看，后续可以做的方向有很多。比如把PINN与时间维度结合，直接推导三维的问题（二维空间加一维时间）；比如在损失中加入已知观测数据，变成PDE+数据的混合求解；比如用自适应采样策略进一步提升精度。

如果看这篇文章的你也正在做PINN求解偏微分方程，我的建议是先把二维Helmholtz这个基准算例跑透，理解每一步的设计意图，再去追更花哨的改进方案。基础流程稳定可靠了，后面所有扩展都会顺很多。