PINNs 训练挑战与解决方案

1. 概述

Physics-Informed Neural Networks (PINNs) 虽然在科学计算中展现出巨大潜力，但其训练过程面临诸多挑战¹。本章系统分析这些挑战并介绍最新的解决方案。

---

2. 训练挑战

2.1 梯度冲突问题

PINNs同时优化多个损失项：

$${\mathcal{L}}_{total}={\mathcal{L}}_{data}+{\lambda }_{pde}{\mathcal{L}}_{pde}+{\lambda }_{bc}{\mathcal{L}}_{bc}+{\lambda }_{ic}{\mathcal{L}}_{ic}$$

问题：不同损失项的梯度方向可能相互冲突，导致训练不稳定。

设 ${\mathbf{g}}_{data}={\nabla }_{\theta }{\mathcal{L}}_{data}$，${\mathbf{g}}_{pde}={\nabla }_{\theta }{\mathcal{L}}_{pde}$，则：

$${\mathbf{g}}_{total}={\mathbf{g}}_{data}+{\lambda }_{pde}{\mathbf{g}}_{pde}$$

当 ${\mathbf{g}}_{data}\cdot {\mathbf{g}}_{pde}<0$ 时，两者在同一方向上相互抵消。

2.2 优化景观复杂性

NeurIPS 2025的最新研究²指出PINNs的优化景观具有以下特点：

1. 高度非凸：多模态局部极小值
2. 鞍点密集：优化路径曲折
3. 曲率变化剧烈：学习率敏感

2.3 频率偏差

神经网络倾向于先学习低频分量（频率原则³），对于包含高频成分的PDE解：

$$u(\mathbf{x})=\sin ({\omega }_1\mathbf{x})+\sin ({\omega }_2\mathbf{x}),{\omega }_2\gg {\omega }_1$$

低频成分快速收敛，高频成分收敛缓慢。

2.4 多尺度问题

物理问题通常涉及多尺度特征：

• 空间多尺度：边界层、奇点
• 时间多尺度：快慢过程耦合
• 参数多尺度：不同参数区域的解行为差异

---

3. 解决方案

3.1 梯度对齐策略 (Gradient Alignment)

NeurIPS 2025提出的梯度对齐方法²通过以下方式解决梯度冲突：

对齐损失：

$${\mathcal{L}}_{align}=\Vert \frac{{\mathbf{g}}_{data}}{\Vert {\mathbf{g}}_{data}\Vert }-\frac{{\mathbf{g}}_{pde}}{\Vert {\mathbf{g}}_{pde}\Vert }{\Vert }^2$$

总损失：

$${\mathcal{L}}_{final}={\mathcal{L}}_{data}+{\lambda }_{pde}{\mathcal{L}}_{pde}+\alpha \cdot {\mathcal{L}}_{align}$$

# 梯度对齐实现
def gradient_alignment_loss(model, x_data, t_data, u_data, x_pde, t_pde):
    # 数据损失
    u_pred = model(x_data, t_data)
    loss_data = nn.MSELoss()(u_pred, u_data)
    g_data = torch.autograd.grad(loss_data, model.parameters(), create_graph=True)
    g_data_flat = torch.cat([g.flatten() for g in g_data])
    
    # PDE损失
    loss_pde = pde_loss(model, x_pde, t_pde)
    g_pde = torch.autograd.grad(loss_pde, model.parameters(), create_graph=True)
    g_pde_flat = torch.cat([g.flatten() for g in g_pde])
    
    # 梯度对齐
    g_data_norm = g_data_flat / (g_data_flat.norm() + 1e-8)
    g_pde_norm = g_pde_flat / (g_pde_flat.norm() + 1e-8)
    loss_align = (g_data_norm - g_pde_norm).norm()
    
    return loss_data + loss_pde + 0.1 * loss_align

3.2 课程学习 (CoPINN)

ICML 2025提出的认知物理信息神经网络 (CoPINN)⁴ 模拟人类认知过程：

渐进式课程：

1. 简单阶段：仅训练数据项
2. 过渡阶段：逐步引入物理约束
3. 困难阶段：完整损失函数

class CoPINN:
    def __init__(self, model, schedule='linear'):
        self.model = model
        self.schedule = schedule
        self.epoch = 0
    
    def get_current_lambda(self):
        """动态调整PDE权重"""
        if self.schedule == 'linear':
            # 线性增加
            return min(1.0, self.epoch / 100)
        elif self.schedule == 'exp':
            # 指数增加
            return 1 - np.exp(-self.epoch / 50)
        else:
            return 1.0
    
    def training_step(self, data_batch, pde_batch):
        self.epoch += 1
        lam = self.get_current_lambda()
        
        loss_data = self.data_loss(data_batch)
        loss_pde = self.pde_loss(pde_batch)
        
        return loss_data + lam * loss_pde

3.3 自适应权重方法

3.3.1 基于梯度范数的权重调整

SoftAdapt (arXiv:2020)：

$${\lambda }_i^{new}=\frac{{\lambda }_i^{old}\cdot \exp (\beta \cdot {\dot{\mathcal{L}}}_i)}{{\sum }_j{\lambda }_j^{old}\cdot \exp (\beta \cdot {\dot{\mathcal{L}}}_j)}$$

其中 ${\dot{\mathcal{L}}}_i$ 是损失变化率。

3.3.2 GradNorm

Chen et al. (ICLR 2018) 提出的GradNorm：

$${\mathcal{L}}_{grad}=\sum _i\Vert {\nabla }_{\theta }{\mathcal{L}}_i\cdot {\bar{G}}_i^{1/\alpha }-G_i^0{\Vert }_1$$

其中 $G_i=\Vert {\mathbf{g}}_i{\Vert }_2$，${\bar{G}}_i$ 是加权平均。

def gradnorm_weight_update(losses, model, alpha=1.5):
    """GradNorm权重更新"""
    gradients = []
    for name, loss in losses.items():
        g = torch.autograd.grad(loss, model.parameters(), retain_graph=True)
        G = sum([g_i.norm()**2 for g_i in g]) ** 0.5
        gradients.append((name, G))
    
    # 计算目标梯度范数
    G_avg = torch.tensor([g for _, g in gradients]).mean()
    G_target = G_avg * (G_avg / torch.tensor([g for _, g in gradients])) ** alpha
    
    # 更新权重
    for name, G in gradients:
        # 简化的权重调整
        weight = G / (G_target[name] + 1e-8)
        losses[name] = weight * losses[name]
    
    return losses

3.4 傅里叶特征嵌入

解决高频问题⁵：

class FourierFeatureMLP(nn.Module):
    def __init__(self, input_dim, hidden_dims, output_dim, mapping_dim=64):
        super().__init__()
        self.mapping = GaussianFourierFeature(mapping_dim)
        
        layers = []
        in_dim = mapping_dim
        for h_dim in hidden_dims:
            layers.extend([nn.Linear(in_dim, h_dim), nn.Tanh()])
            in_dim = h_dim
        layers.append(nn.Linear(in_dim, output_dim))
        self.net = nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.mapping(x)
        return self.net(x)
 
class GaussianFourierFeature(nn.Module):
    """高斯傅里叶特征映射"""
    def __init__(self, dim, scale=1.0):
        super().__init__()
        self.B = nn.Parameter(
            torch.randn(dim, 2) * scale, 
            requires_grad=False
        )
    
    def forward(self, x):
        # x: (batch, 1) 或 (batch, d)
        x_proj = 2 * np.pi * torch.matmul(x, self.B.T)
        return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)

3.5 多尺度损失重采样

针对多尺度问题的自适应采样：

class MultiScaleSampler:
    def __init__(self, model, ref_samples=1000):
        self.model = model
        self.ref_samples = ref_samples
    
    def sample(self, domain, n_samples):
        # 第一阶段：均匀采样
        x_uniform = torch.rand(n_samples, domain.dim) * domain.size
        
        # 计算PDE残差
        x_uniform.requires_grad_(True)
        residual = self.compute_residual(x_uniform)
        
        # 基于残差的非均匀采样
        probs = residual.abs() / residual.abs().sum()
        indices = torch.multinomial(probs, min(n_samples, self.ref_samples))
        x_refined = x_uniform[indices]
        
        # 合并
        x_final = torch.cat([x_uniform[:n_samples//2], x_refined[:n_samples//2]], dim=0)
        return x_final.detach()

3.6 学习率调度

调度策略	描述	适用场景
Warmup + Cosine	预热后余弦退火	稳定训练
Cyclic LR	周期性学习率	跳出局部极小
OneCycleLR	单周期策略	快速收敛

# 学习率调度器组合
scheduler = torch.optim.lr_scheduler.OneCycleLR(
    optimizer,
    max_lr=1e-3,
    epochs=100,
    steps_per_epoch=len(dataloader),
    pct_start=0.1,  # 10%预热
    anneal_strategy='cos'
)

---

4. 训练稳定性技巧

4.1 权重初始化

使用适合PDE解的初始化方法：

def pde_aware_init(model, domain):
    """物理感知初始化"""
    with torch.no_grad():
        # 初始化为线性解的近似
        for m in model.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_normal_(m.weight)
                if m.bias is not None:
                    nn.init.zeros_(m.bias)

4.2 梯度裁剪

def train_step(model, optimizer, data_batch, pde_batch, max_grad_norm=1.0):
    loss = compute_loss(model, data_batch, pde_batch)
    loss.backward()
    
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
    optimizer.step()
    optimizer.zero_grad()
    
    return loss

4.3 混合精度训练

scaler = torch.cuda.amp.GradScaler()
 
def train_step_amp(model, optimizer, data_batch, pde_batch):
    with torch.cuda.amp.autocast():
        loss = compute_loss(model, data_batch, pde_batch)
    
    scaler.scale(loss).backward()
    scaler.unscale_(optimizer)
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    scaler.step(optimizer)
    scaler.update()

---

5. 评估指标

5.1 相对L2误差

$$\text{RelL2}=\frac{\Vert u_{pred}-u_{true}{\Vert }_2}{\Vert u_{true}{\Vert }_2}$$

5.2 最大绝对误差

$$\text{MaxAE}=\underset{i}{\max }|u_{pred}({\mathbf{x}}_i)-u_{true}({\mathbf{x}}_i)|$$

5.3 能量误差（物理一致性）

$$\text{EnergyErr}=\Vert \mathcal{N}[u_{pred}]{\Vert }_2$$

---

6. 最佳实践总结

1. 使用傅里叶特征处理高频问题
2. 课程学习提高训练稳定性
3. 自适应权重解决梯度冲突
4. 多尺度采样处理多尺度问题
5. 学习率预热避免初期震荡
6. 梯度裁剪防止梯度爆炸
7. 残差采样优先探索高误差区域

---

7. 参考文献

---

相关主题

• PINNs基础理论
• PINNs的NTK分析
• 神经算子理论
• 频率原则与神经网络

Footnotes

1. Cuomo, S., et al. (2022). Physics-informed neural networks for surrogate modeling with application to fluiddynamics. Computers & Mathematics with Applications. ↩

2. Wang, Y., et al. (2025). Gradient Alignment in Physics-Informed Neural Networks. NeurIPS 2025. ↩ ↩²

3. Xu, Z., et al. (2019). Frequency Principle: Fourier Neural Networks Can Learn Low-frequency Functions First. ICLR Workshop 2019. ↩

4. Chen, L., et al. (2025). CoPINN: Cognitive Physics-Informed Neural Networks. ICML 2025. ↩

5. Tancik, M., et al. (2020). Fourier Features Let Networks Learn High Frequency Functions in Low Dimensional Domains. NeurIPS 2020. ↩