Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

用python编写一个PINN深度神经网络求解二阶微分方程边值问题的示例程序。采用pytorch库,输出误差随训练步骤变化的图像。二阶微分方程要复杂点,两个边值不同。

  1. User

    用python编写一个PINN深度神经网络求解二阶微分方程边值问题的示例程序。采用pytorch库,输出误差随训练步骤变化的图像。二阶微分方程要复杂点,两个边值不同。

  2. Assistant

    下面是一个使用Python和PyTorch库实现的物理信息神经网络(PINN)示例,用于求解一个复杂的二阶非线性微分方程的边值问题。该示例选择的微分方程为:

    [ \frac{d^2u}{dx^2} + e^{u} = 0, \quad x \in [0, 1], ]

    边界条件为:

    [ u(0) = 0, \quad u(1) = 1. ]

    该方程是非线性的,且边界条件在两个端点不同,使得问题更加复杂。代码中定义了一个简单的神经网络结构,通过最小化微分方程残差和边界条件的误差来训练模型。训练过程中会记录损失值,并在训练结束后绘制误差随训练步骤变化的图像。

    代码实现

    import torch
    import torch.nn as nn
    import torch.optim as optim
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 设置随机种子确保结果可复现
    torch.manual_seed(0)
    np.random.seed(0)
    
    # 定义神经网络结构
    class PINN(nn.Module):
        def __init__(self, layers):
            super(PINN, self).__init__()
            self.activation = nn.Tanh()
            layer_list = []
            for i in range(len(layers)-1):
                layer_list.append(nn.Linear(layers[i], layers[i+1]))
            self.layers = nn.ModuleList(layer_list)
            
            # 权重初始化
            for m in self.layers:
                nn.init.xavier_normal_(m.weight.data, gain=1.0)
                nn.init.zeros_(m.bias.data)
            
        def forward(self, x):
            out = x
            for i in range(len(self.layers)-1):
                out = self.activation(self.layers[i](out))
            out = self.layers[-1](out)
            return out
    
    # 定义物理信息损失函数
    def physics_loss(model, x):
        x = x.requires_grad_(True)
        u = model(x)
        
        # 计算一阶导数
        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]
        
        # 定义微分方程的残差
        f = u_xx + torch.exp(u)
        return torch.mean(f**2)
    
    # 定义边界条件损失函数
    def boundary_loss(model, xb, ub):
        u_pred = model(xb)
        return torch.mean((u_pred - ub)**2)
    
    # 定义域内采样点
    def generate_interior_points(N):
        x = np.random.uniform(low=0.0, high=1.0, size=(N,1))
        x = torch.tensor(x, dtype=torch.float32)
        return x
    
    # 定义边界点
    def get_boundary_points():
        x_b = torch.tensor([[0.0],[1.0]], dtype=torch.float32)
        u_b = torch.tensor([[0.0],[1.0]], dtype=torch.float32)
        return x_b, u_b
    
    # 主训练函数
    def train_PINN():
        # 定义网络层数
        layers = [1, 20, 20, 20, 1]
        model = PINN(layers)
        
        # 定义优化器
        optimizer = optim.Adam(model.parameters(), lr=1e-3)
        
        # 训练参数
        epochs = 10000
        N_interior = 100  # 内部采样点数
        loss_history = []
        
        # 获取边界点
        x_b, u_b = get_boundary_points()
        
        for epoch in range(epochs):
            optimizer.zero_grad()
            
            # 采样内部点
            x_in = generate_interior_points(N_interior)
            
            # 计算损失
            loss_f = physics_loss(model, x_in)
            loss_b = boundary_loss(model, x_b, u_b)
            loss = loss_f + loss_b
            
            # 反向传播
            loss.backward()
            optimizer.step()
            
            # 记录损失
            loss_history.append(loss.item())
            
            # 打印日志
            if (epoch+1) % 1000 == 0:
                print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.6f}, Physics Loss: {loss_f.item():.6f}, Boundary Loss: {loss_b.item():.6f}')
        
        # 绘制误差随训练步骤变化的图像
        plt.figure(figsize=(8,5))
        plt.plot(loss_history, label='Total Loss')
        plt.yscale('log')
        plt.xlabel('Epoch')
        plt.ylabel('Loss (log scale)')
        plt.title('Loss vs. Training Epochs')
        plt.legend()
        plt.grid(True)
        plt.show()
        
        # 绘制预测解与真实解对比
        with torch.no_grad():
            x_star = torch.linspace(0,1,100).reshape(-1,1)
            u_star = model(x_star).numpy()
            
            # 假设真实解未知,这里仅展示预测解
            plt.figure(figsize=(8,5))
            plt.plot(x_star.numpy(), u_star, 'r-', label='Predicted Solution')
            plt.xlabel('x')
            plt.ylabel('u(x)')
            plt.title('Predicted Solution by PINN')
            plt.legend()
            plt.grid(True)
            plt.show()
        
    if __name__ == "__main__":
        train_PINN()
    

    代码说明

    1. 神经网络结构 (PINN 类):

      • 使用一个具有三层隐藏层的全连接神经网络,每层包含20个神经元,激活函数为双曲正切(Tanh)。
      • 权重采用Xavier初始化方法,偏置初始化为零。
    2. 损失函数:

      • 物理损失 (physics_loss): 计算微分方程 ( u''(x) + e^{u} = 0 ) 的残差的均方误差。通过自动微分计算一阶和二阶导数。
      • 边界条件损失 (boundary_loss): 计算预测的边界值与实际边界值之间的均方误差。
    3. 数据采样:

      • 内部点 (generate_interior_points): 在域 ([0,1]) 内随机采样100个点用于计算物理损失。
      • 边界点 (get_boundary_points): 固定边界点 ( x = 0 ) 和 ( x = 1 ),对应的边界条件 ( u(0) = 0 ) 和 ( u(1) = 1 )。
    4. 训练过程:

      • 使用Adam优化器,学习率为0.001。
      • 进行10,000个训练步骤,每1000步打印一次损失信息。
      • 训练过程中记录总损失,用于后续绘图。
    5. 结果展示:

      • 损失曲线: 以对数尺度绘制总损失随训练步数的变化,展示模型的收敛情况。
      • 预测解: 绘制模型预测的 ( u(x) ) 随 ( x ) 的变化曲线。由于真实解可能未知,这里仅展示预测结果。

    注意事项

    • 自动微分: PyTorch的自动微分功能使得计算高阶导数变得简便。
    • 非线性方程: 由于方程 ( u''(x) + e^{u} = 0 ) 是非线性的,训练可能需要更多的迭代次数或调整网络结构以获得更好的收敛效果。
    • 学习率和优化器: 可以尝试不同的学习率或优化器(如L-BFGS)来提升训练效果。

    运行上述代码后,您将看到训练过程中总损失的下降趋势,以及最终的预测解曲线。这个示例展示了如何利用PINN方法求解复杂的二阶微分方程边值问题,并通过图像直观地展示误差的变化情况。