DNN(深度神经网络)近似 Lyapunov 函数

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
# from torchviz import make_dot
import torchviz


# 1. Lyapunov 函数近似器（MLP 结构）
class LyapunovNet(nn.Module):
    def __init__(self, input_dim, hidden_dim=32):
        super(LyapunovNet, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 1)  # 输出一个标量，表示Lyapunov函数值
        )
    
    def forward(self, x):
        return self.model(x)

# 2. 梯度伴随网络（计算 Lyapunov 函数的梯度）
def compute_gradient(model, x):
    x.requires_grad_(True)
    V = model(x)
    grad_V = torch.autograd.grad(V.sum(), x, create_graph=True)[0]
    return V, grad_V

# 3. 训练数据（随机生成一些状态数据）
def generate_data(num_samples=1000, state_dim=2):
    return torch.randn(num_samples, state_dim) * 5  # 扩大范围

# 4. 网络权重初始化
def init_weights(m):
    if isinstance(m, nn.Linear):
        torch.nn.init.xavier_uniform_(m.weight)
        if m.bias is not None:
            torch.nn.init.zeros_(m.bias)

# 5. 训练 Lyapunov 网络并绘制损失曲线
def train_lyapunov_net(state_dim=2, epochs=500, lr=0.001):
    model = LyapunovNet(input_dim=state_dim)
    model.apply(init_weights)  # 重新初始化网络
    optimizer = optim.Adam(model.parameters(), lr=lr)
    loss_history = []
    
    for epoch in range(epochs):
        x = generate_data()
        V, grad_V = compute_gradient(model, x)
        
        # 修正损失函数
        loss = torch.mean(torch.relu(-grad_V.sum(dim=1))) + torch.mean(torch.relu(-V))
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        loss_history.append(loss.item())
        
        if epoch % 50 == 0:
            print(f"Epoch {
     
     epoch}, Loss: {
     
     loss.item():.6f}")
    
    # 绘制损失曲线
    plt.plot(loss_history)
    plt.xlabel("Epoch")
    plt.ylabel("Loss")
    plt.title("Training Loss Curve")
    plt.grid()
    plt.show()
    
    return model

# 6. 可视化神经网络计算图
def visualize_lyapunov_network(model, state_dim=2):
    x = torch.randn(1, state_dim, requires_grad=True)  # 生成一个测试输入
    V = model(x)
    dot = make_dot(V, params=dict(model.named_parameters()))
    dot.format = 'png'
    dot.render('lyapunov_network')  # 生成 PNG 图片
    dot.view()  # 打开图像

if __name__ == "__main__":
    trained_model = train_lyapunov_net()
    visualize_lyapunov_network(trained_model)

这段代码的核心目标是使用神经网络近似 Lyapunov 函数，并通过梯度信息优化其参数，以确保 Lyapunov 函数在物理系统的状态空间中满足稳定性条件。以下是详细的解析：

1. 代码整体架构

该代码主要包含 6 个部分：

1. 定义 Lyapunov 函数近似器（MLP 神经网络）。
2. 计算 Lyapunov 函数的梯度（用于优化）。
3. 生成训练数据（模拟状态空间点）。
4. 初始化网络权重（Xavier 初始化）。
5. 训练 Lyapunov 网络（基于梯度信息优化 Lyapunov 函数）。
6. 可视化网络结构（绘制计算图）。

2. 详细解析每个部分

(1) Lyapunov 函数近似器

class LyapunovNet(nn.Module):
    def __init__(self, input_dim, hidden_dim=32):
        super(LyapunovNet, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),