使用硬约束的物理信息神经网络（PINNs，Physics-Informed Neural Networks）求解一维泊松方程

背景

一维泊松方程定义为： u ′ ′ ( x ) = f ( x ) u''(x) = f(x) u′′(x)=f(x)，边界条件为 x = 0 x=0 x=0 和 x = 1 x=1 x=1 处， u ( x ) = 0 u(x) = 0 u(x)=0，其中， f ( x ) = − π 2 sin ⁡ ( π x ) f(x) = -\pi^2 \sin(\pi x) f(x)=−π2sin(πx)，该方程的解析解为 u ( x ) = sin ⁡ ( π x ) u(x) = \sin(\pi x) u(x)=sin(πx)。

硬约束原理

硬约束在 PINNs 中用来确保边界条件自动满足。构建硬约束，即解： u ( x ) = x ( 1 − x ) N ( x ) u(x) = x(1-x)N(x) u(x)=x(1−x)N(x)。

边界条件自动满足 ：函数形式 x ( 1 − x ) x(1-x) x(1−x) 保证在边界 x = 0 x=0 x=0 和 x = 1 x=1 x=1 处， u ( x ) = 0 u(x) = 0 u(x)=0，这就是硬约束。
神经网络输出 ： N ( x ) N(x) N(x) 是神经网络的输出，没有边界限制，任意预测。

代码

python 复制代码

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams[
'axes.unicode_minus'] = False
# 定义一个神经网络类，继承自tf.keras.Model
class PINN(tf.keras.Model):    
def __init__(self, num_hidden_layers=3, num_neurons_per_layer=20):        
# 调用父类的初始化函数        
super(PINN, self).__init__()        
# 创建一个隐藏层的列表，每个隐藏层是一个全连接层，使用tanh作为激活函数
        self.hidden_layers = [tf.keras.layers.Dense(num_neurons_per_layer, activation='tanh')                              
for _ in range(num_hidden_layers)]        
# 创建输出层，输出为一维，没有激活函数（线性激活）
        self.output_layer = tf.keras.layers.Dense(1, activation=None)
    # 定义前向传播的方法    
def call(self, x):        
# 初始输入值
        z = x        
# 通过每一个隐藏层        
for layer in self.hidden_layers:
            z = layer(z)        
# 输出层得到最终输出        
return self.output_layer(z)
# 自定义训练步骤
@tf.function
def train_step(model, optimizer, x):    
# 使用tf.GradientTape()记录梯度信息    
with tf.GradientTape() as tape:        
# 预测 u(x) = x(1-x)N(x)，其中N(x)是神经网络的输出
        u_pred = x * (1 - x) * model(x)                
# 计算 u'(x) 使用自动微分
        u_x = tf.gradients(u_pred, x)[0]        
# 计算 u''(x) 使用自动微分
        u_xx = tf.gradients(u_x, x)[0]                
# 定义泊松方程中的右侧项 f(x)
        f = -np.pi**2 * tf.sin(np.pi * x)        
# 计算损失函数，衡量 u''(x) 和 f(x) 的差距
        loss = tf.reduce_mean(tf.square(u_xx - f))        
# 计算损失函数关于模型参数的梯度
    gradients = tape.gradient(loss, model.trainable_variables)    
# 使用优化器更新模型参数
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))    
return loss
# 准备训练数据，生成从0到1的100个点
x_train = np.linspace(0, 1, 100)[:, None]
x_train = tf.convert_to_tensor(x_train, dtype=tf.float32)
# 初始化PINN模型和Adam优化器
model = PINN()
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
# 训练模型，迭代1000次
epochs = 1000
for epoch in range(epochs):    
# 每次训练计算损失值
    loss_value = train_step(model, optimizer, x_train)    
# 每隔100次输出一次损失值    
if epoch % 100 == 0:        
print(f"Epoch {epoch}, Loss: {loss_value.numpy()}")
# 生成测试数据用于结果可视化
x_test = np.linspace(0, 1, 100)[:, None]
x_test = tf.convert_to_tensor(x_test, dtype=tf.float32)
# 使用训练好的模型进行预测
u_pred = x_test * (1 - x_test) * model(x_test)
# 绘制预测结果和精确解进行对比
plt.plot(x_test, u_pred, label='PINN Prediction')
plt.plot(x_test, np.sin(np.pi * x_test), label='Exact Solution', linestyle='dashed')
plt.legend()
plt.xlabel('x')
plt.ylabel('u(x)')
plt.title('PINN硬约束解一维泊松方程')
plt.show()

代码解析

PINN 类定义：
- PINN 类是一个继承自 tf.keras.Model 的神经网络，包含多个全连接层。
- 使用 tanh 激活函数处理隐藏层，输出层是线性激活。
前向传播：
- call 方法定义了前向传播过程：输入通过各层处理后，输出为 N ( x ) N(x) N(x)。
自定义训练步骤：
- 使用 tf.GradientTape() 记录梯度信息，计算神经网络输出 N ( x ) N(x) N(x) 的二阶导数 u ′ ′ ( x ) u''(x) u′′(x)。
- 损失函数衡量 u ′ ′ ( x ) u''(x) u′′(x) 和右侧项 f ( x ) f(x) f(x) 的差距。
训练过程：
- 使用 Adam 优化器迭代更新模型参数，逐步减少损失。
- 每 100 个 epoch 输出损失值以监控训练过程。
预测与可视化：
- 在训练完成后，使用模型对测试数据进行预测。
- 绘制模型预测结果与解析解进行对比。

物理信息的引入

使用自动微分计算模型预测值的导数，从而在损失函数中比较预测和物理方程的右侧项。
硬约束通过预先定义的函数形式确保边界条件被满足。

优势

边界条件处理：硬约束方法无需在损失函数中显式加入边界条件损失。
物理一致性：神经网络能够学习到方程的物理特性。