使用软约束的物理信息神经网络解一维泊松方程

物理信息神经网络是一种将物理方程和神经网络结合的方法，通过将方程的物理约束转化为损失函数的一部分来指导神经网络的训练。下面是软约束的物理信息神经网络求解一维泊松方程。

数学原理

目标方程：
- 一维泊松方程，形式为 u ′ ′ ( x ) = f ( x ) u''(x) = f(x) u′′(x)=f(x)，其中 f ( x ) = − π 2 sin ⁡ ( π x ) f(x) = -\pi^2 \sin(\pi x) f(x)=−π2sin(πx)。
边界条件：
- 在边界 x = 0 x = 0 x=0 和 x = 1 x = 1 x=1 上，给定 u ( 0 ) = 0 u(0) = 0 u(0)=0 和 u ( 1 ) = 0 u(1) = 0 u(1)=0。
神经网络模型：
- 使用一个多层神经网络来近似解 u ( x ) u(x) u(x)。
- 网络的输入是 x x x，输出是 u ( x ) u(x) u(x)。
损失函数：
- 内部点损失 ：通过自动微分计算 u ′ ′ ( x ) u''(x) u′′(x)，并与给定的 f ( x ) f(x) f(x) 进行比较：
  l o s s i n t e r i o r = 1 N ∑ i = 1 N ( u ′ ′ ( x i ) − f ( x i ) ) 2 loss_{interior} = \frac{1}{N} \sum_{i=1}^{N} (u''(x_i) - f(x_i))^2 lossinterior=N1i=1∑N(u′′(xi)−f(xi))2
- 边界条件损失 ：直接计算在边界点的偏差：
  l o s s b c = u ( 0 ) 2 + u ( 1 ) 2 loss_{bc} = u(0)^2 + u(1)^2 lossbc=u(0)2+u(1)2
总损失：
- 总损失是内部点损失和边界条件损失的加权和：
  l o s s = l o s s i n t e r i o r + l o s s b c loss = loss_{interior} + loss_{bc} loss=lossinterior+lossbc
- 这里，内部点损失和边界条件损失共同构成了优化目标，其中边界条件损失可以被视为软约束，因为它在损失函数中作为一项，而非严格的约束条件。

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__()
        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):    
with tf.GradientTape() as tape:        
# 预测 u(x) = N(x)，直接使用神经网络的输出
        u_pred = 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_interior = tf.reduce_mean(tf.square(u_xx - f))                
# 边界条件损失：在 x=0 和 x=1 处，u(x) 应为 0
        u_0 = model(tf.constant([[0.0]], dtype=tf.float32))
        u_1 = model(tf.constant([[1.0]], dtype=tf.float32))
        loss_bc = tf.square(u_0) + tf.square(u_1)                
# 总损失
        loss = loss_interior + loss_bc
    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)    
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 = 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.savefig('图片/pinn_poisson_solution_soft.png', dpi=300, bbox_inches='tight')

代码解释

PINN模型的构建：
- PINN类定义了一个简单的前馈神经网络，具有3个隐藏层，每层20个神经元，使用tanh激活函数。输出层不使用激活函数，以保持输出的线性。
自定义训练步骤：
- 在train_step函数中，通过自动微分计算网络输出的二阶导数 u ′ ′ ( x ) u''(x) u′′(x)，并与泊松方程的右端项 f ( x ) f(x) f(x) 进行比较。
- 使用tf.GradientTape计算损失相对于网络参数的梯度，并使用Adam优化器更新参数。
软约束的实现：
- 边界条件损失 l o s s b c loss_{bc} lossbc 被添加到总损失中，作为优化的一个软约束。这意味着网络在训练过程中不仅需要拟合内部点的方程，还要尽量满足边界条件。
训练过程：
- 使用100个从0到1均匀分布的点作为训练数据。
- 通过1000次迭代优化网络参数，最小化总损失。
结果可视化：
- 使用训练后的模型对从0到1的测试点进行预测，可以与真实解进行比较以评估模型性能。