【PINN】DeepXDE学习训练营(30)——pinn_forward-elasticity_plate.py

灵犀拾荒者

于 2025-05-21 10:00:00 发布

阅读量1.2k

点赞数 39

CC 4.0 BY-SA版权

分类专栏： PINN Py 文章标签：学习神经网络人工智能 PINN 深度学习

本文链接：https://blog.csdn.net/2303_77200324/article/details/148015559

Py 同时被 2 个专栏收录

84 篇文章

订阅专栏

PINN

39 篇文章

订阅专栏

一、引言

随着人工智能技术的飞速发展，深度学习在图像识别、自然语言处理等领域的应用屡见不鲜，但在科学计算、工程模拟以及物理建模方面，传统的数值方法仍然占据主导地位。偏微分方程（Partial Differential Equations, PDEs）作为描述自然界中众多复杂现象的重要数学工具，在物理、化学、工程、金融等领域具有广泛应用。然而，伴随着高维度、多变量、复杂边界条件等挑战，传统数值求解方法面临效率低、适应性差等困境。

近年来，深度学习的崛起为科学计算带来了全新的解决思路。其中，以深度偏微分方程（Deep PDE）为代表的研究方向，通过结合神经网络与偏微分方程的理论，成功开发出高效、灵活的求解方案。这种方法不仅可以克服传统方法的局限，还能应对高维、复杂几何等问题。

作为深度偏微分方程领域的开源工具库，DeepXDE（Deep Learning for Differential Equations）由lululxvi团队精心开发，凭借其强大的功能、易用的接口和丰富的示例，受到学术界与工业界的广泛关注。本文将系统介绍DeepXDE的基本内容与应用价值，深入探讨其核心技术原理，分享环境配置与运行技巧，并结合实际案例进行分析，最后对未来发展趋势进行展望。

二、DeepXDE的用途

DeepXDE，一个基于TensorFlow和PyTorch的深度学习微分方程求解库，应运而生。它提供了一个简洁、高效且易于使用的框架，使得研究人员和工程师能够利用深度学习技术求解各种类型的微分方程，包括常微分方程（ODEs）、偏微分方程（PDEs）、积分微分方程（IDEs）以及分数阶微分方程（FDEs）。

DeepXDE旨在提供一站式的深度学习框架，用于高效求解各种偏微分方程，包括但不限于：

1. 传统偏微分方程求解

定常和非定常问题：热传导方程、波动方程、拉普拉斯方程、扩散方程等。
线性和非线性方程：支持线性边界条件，也能处理非线性、非局部问题。

2. 高维偏微分方程

在高维空间中，传统数值方法面临“维数灾难”。DeepXDE利用神经网络天然的高维逼近能力，有效解决高维PDE，如贝尔曼方程、多体问题等。

3. 复杂几何和边界条件

支持任意复杂的几何区域、非均匀边界条件，极大扩展了求解的适用范围。

4.参数逆问题和数据驱动建模

整合数据，使模型在已知部分信息的基础上进行参数识别、反演问题求解。

5. 动态系统和时间演化

支持带有时间变量的演化问题，模拟动态过程。

6. 结合有限元、有限差分等方法

虽然核心为神经网络，但兼容各种数值方法，提供灵活的求解策略。

7. 教育科研与工程实践

丰富的案例与接口帮助科研人员快速验证理论，工程师实现快速设计优化。

总结而言，DeepXDE不仅是一个纯粹的数学工具，更是工程实践中的“聪明助手”，帮助用户以信赖深度学习的方式突破传统技术瓶颈，实现创新性的科学计算。

三、核心技术原理

DeepXDE的核心思想是利用神经网络作为逼近器，通过构造损失函数，使网络能在满足偏微分方程边界条件的前提下逼近真实解。以下详细阐释其原理基础。

1. 神经网络逼近偏微分方程解

假设待求解的偏微分方程可以写成：

$\mathcal{N}[u](x)=0,x\in\Omega,$

配合边界条件

$\mathcal{B}[u](x)=g(x),x\in\partial \Omega,$

这里， $\mathcal{N}$ 代表微分算子， $\mathcal{B}$ 代表边界条件算子。

DeepXDE利用深度神经网络 𝑢𝜃(𝑥) 作为解的逼近，参数为 𝜃 。通过自动微分（AutoDiff），网络可以自然求出 𝑢𝜃 的各阶导数，从而在网络定义的每个点上计算微分方程的残差。

2. 损失函数设计

训练模型的目标是最小化残差，使神经网络逼近满足偏微分方程的解。损失函数由两部分组成：

方程残差部分：

$\mathcal{L}_{\mathit{PDE}}=\frac{1}{N_{f}}\sum_{i=1}^{N_{f}}|\mathcal{N}[u_{ \theta}](x_{f}^{(i)})|^{2},$

其中， $x{_{f}}^{(i)}$ 为采样点，用于评估微分残差。

边界条件部分：

$\mathcal{L}_{\mathit{BC}}=\frac{1}{N_{b}}\sum_{i=1}^{N_{b}}|\mathcal{B}[u_{ \theta}](x_{b}^{(i)})-g(x_{b}^{(i)})|^{2},$

结合整体目标函数：

$\mathcal{L}(\theta)=\lambda_{f}\mathcal{L}_{\mathit{PDE}}+\lambda_{b} \mathcal{L}_{\mathit{BC}},$

这里 $\lambda {_{f}}$ 、 $\lambda {_{b}}$ 为调节系数。

3. 自动微分（AutoDiff）技术

深度学习框架如TensorFlow或PyTorch提供自动微分功能，方便快速计算神经网络输入的微分，自动应用链式法则求导，极大简化偏微分方程的数值差分表达。

4. 训练优化方法

利用成熟的梯度下降（SGD）、Adam等优化算法，通过反向传播调节神经网络参数，使损失函数达到最小。

5. 样本生成和采样策略

采样点生成：采用随机采样、拉丁超立方（Latin Hypercube Sampling）或网格采样来选取训练点。
自适应采样：在训练过程中，根据误差分布调整采样点，提高训练效率。

6. 复杂边界与几何的处理

采用非结构化的几何描述和SDF（Signed Distance Function）结合，保证不同几何形状的灵活支持。

7. 逆问题与数据融合

在已知数据集上引入数据损失，使模型不仅满足PDE，也通过端到端训练实现数据匹配，增强实际适用性。

五、代码详解

"""支持的后端：pytorch, paddle"""

import deepxde as dde
import numpy as np

# 根据后端选择对应的数值计算库
if dde.backend.backend_name == "pytorch":
    import torch
    sin = torch.sin
    cos = torch.cos
elif dde.backend.backend_name == "paddle":
    import paddle
    sin = paddle.sin
    cos = paddle.cos

# 定义几何区域为矩形，[0,0]到[1,1]
geom = dde.geometry.Rectangle([0, 0], [1, 1])

# 定义边界条件检测函数
def boundary_left(x, on_boundary):
    return on_boundary and dde.utils.isclose(x[0], 0.0)

def boundary_right(x, on_boundary):
    return on_boundary and dde.utils.isclose(x[0], 1.0)

def boundary_top(x, on_boundary):
    return on_boundary and dde.utils.isclose(x[1], 1.0)

def boundary_bottom(x, on_boundary):
    return on_boundary and dde.utils.isclose(x[1], 0.0)

# 定义解析解，用于边界条件和验证
def func(x):
    ux = np.cos(2 * np.pi * x[:, 0:1]) * np.sin(np.pi * x[:, 1:2])
    uy = np.sin(np.pi * x[:, 0:1]) * Q * x[:, 1:2] ** 4 / 4
    # 计算应变分量的二阶偏导（应变梯度）
    E_xx = -2 * np.pi * np.sin(2 * np.pi * x[:, 0:1]) * np.sin(np.pi * x[:, 1:2])
    E_yy = np.sin(np.pi * x[:, 0:1]) * Q * x[:, 1:2]
    E_xy = 0.5 * (
        np.pi * np.cos(2 * np.pi * x[:, 0:1]) * np.cos(np.pi * x[:, 1:2])
        + np.pi * np.cos(np.pi * x[:, 0:1]) * Q * x[:, 1:2] ** 4 / 4
    )
    # 线弹性应力张量组成部分
    Sxx = E_xx * (2 * mu + lmbd) + E_yy * lmbd
    Syy = E_yy * (2 * mu + lmbd) + E_xx * lmbd
    Sxy = 2 * E_xy * mu
    return np.hstack((ux, uy, Sxx, Syy, Sxy))  # 输出包括位移和应力分量

# 定义边界条件：在上下边界，u_x=0; 在左右边界，u_y=0; 在顶部，应力Sxx满足特定条件
ux_top_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_top, component=0)
ux_bottom_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_bottom, component=0)
uy_left_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_left, component=1)
uy_bottom_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_bottom, component=1)
uy_right_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_right, component=1)
sxx_left_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_left, component=2)
sxx_right_bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary_right, component=2)
syy_top_bc = dde.icbc.DirichletBC(
    geom,
    lambda x: (2 * mu + lmbd) * Q * np.sin(np.pi * x[:, 0:1]),
    boundary_top,
    component=3,
)

# 体积力（右端力）函数，用于PDE残差
def fx(x):
    return (
        -lmbd
        * (
            4 * np.pi**2 * cos(2 * np.pi * x[:, 0:1]) * sin(np.pi * x[:, 1:2])
            - Q * x[:, 1:2] ** 3 * np.pi * cos(np.pi * x[:, 0:1])
        )
        - mu
        * (
            np.pi**2 * cos(2 * np.pi * x[:, 0:1]) * sin(np.pi * x[:, 1:2])
            - Q * x[:, 1:2] ** 3 * np.pi * cos(np.pi * x[:, 0:1])
        )
        - 8 * mu * np.pi**2 * cos(2 * np.pi * x[:, 0:1]) * sin(np.pi * x[:, 1:2])
    )

def fy(x):
    return (
        lmbd
        * (
            3 * Q * x[:, 1:2] ** 2 * sin(np.pi * x[:, 0:1])
            - 2 * np.pi**2 * cos(np.pi * x[:, 1:2]) * sin(2 * np.pi * x[:, 0:1])
        )
        - mu
        * (
            2 * np.pi**2 * cos(np.pi * x[:, 1:2]) * sin(2 * np.pi * x[:, 0:1])
            + (Q * x[:, 1:2] ** 4 * np.pi**2 * sin(np.pi * x[:, 0:1])) / 4
        )
        + 6 * Q * mu * x[:, 1:2] ** 2 * sin(np.pi * x[:, 0:1])
    )

# 定义弹性变形的PDE残差
def pde(x, f):
    # 计算应变梯度（每个分量的偏导数）
    E_xx = dde.grad.jacobian(f, x, i=0, j=0)
    E_yy = dde.grad.jacobian(f, x, i=1, j=1)
    E_xy = 0.5 * (dde.grad.jacobian(f, x, i=0, j=1) + dde.grad.jacobian(f, x, i=1, j=0))
    # 计算应力张量的组成部分
    S_xx = E_xx * (2 * mu + lmbd) + E_yy * lmbd
    S_yy = E_yy * (2 * mu + lmbd) + E_xx * lmbd
    S_xy = E_xy * 2 * mu
    # 计算应力梯度（作为动量守恒的微分项）
    Sxx_x = dde.grad.jacobian(f, x, i=2, j=0)
    Syy_y = dde.grad.jacobian(f, x, i=3, j=1)
    Sxy_x = dde.grad.jacobian(f, x, i=4, j=0)
    Sxy_y = dde.grad.jacobian(f, x, i=4, j=1)
    # 动量守恒方程（平衡方程）偏微分
    momentum_x = Sxx_x + Sxy_y - fx(x)
    momentum_y = Sxy_x + Syy_y - fy(x)
    # 残差包括应力差异
    stress_x = S_xx - f[:, 2:3]
    stress_y = S_yy - f[:, 3:4]
    stress_xy = S_xy - f[:, 4:5]
    return [momentum_x, momentum_y, stress_x, stress_y, stress_xy]

# 定义训练数据集
data = dde.data.PDE(
    geom,
    pde,
    [
        ux_top_bc,
        ux_bottom_bc,
        uy_left_bc,
        uy_bottom_bc,
        uy_right_bc,
        sxx_left_bc,
        sxx_right_bc,
        syy_top_bc,
    ],
    num_domain=500,       # 训练域采样点
    num_boundary=500,     # 边界采样点
    solution=func,
    num_test=100,         # 测试点
)

# 构建神经网络：输入两个变量（x,y），多层隐藏层，每层宽度为40
layers = [2, [40] * 5, [40] * 5, [40] * 5, [40] * 5, 5]
activation = "tanh"
initializer = "Glorot uniform"

# 使用Pinn结构（带偏导的神经网络）
net = dde.nn.PFNN(layers, activation, initializer)

# 定义模型
model = dde.Model(data, net)
# 编译模型，优化器Adam，学习率0.001
model.compile("adam", lr=0.001)
# 训练模型，迭代5000次
losshistory, train_state = model.train(epochs=5000)

# 结果可视化
dde.saveplot(losshistory, train_state, issave=True, isplot=True)

这段代码使用 DeepXDE 库来求解二维线性弹性问题。它定义了几何区域、边界条件、体力函数、精确解和偏微分方程，并使用 PFNN 神经网络来逼近解。与之前的例子相比，此示例求解的是一个更复杂的物理问题，并且使用了 PFNN 神经网络，该网络更适合于求解物理问题。代码还展示了如何在 DeepXDE 中使用不同的后端 (PyTorch 或 PaddlePaddle)。