减振系统智能控制算法毕业论文【附代码+数据】

本文链接：https://blog.csdn.net/checkpaper/article/details/142619752

✅博主简介：本人擅长数据处理、建模仿真、论文写作与指导，科研项目与课题交流。项目合作可私信或扫描文章底部二维码。

（一）基于强化学习的 PID 参数自适应整定技术路线

DDPG-PID 映射回路构建
- 为了解决稳定控制减振系统背景下的 PID 控制器参数自适应整定问题，基于深度确定性策略梯度（DDPG）算法构建了 DDPG-PID 映射回路。在减振系统中，PID 控制器起着关键的作用，通过调整比例、积分和微分三个参数来实现对系统的精确控制。DDPG 算法是一种强化学习算法，它具有强大的学习能力和适应性。在这个映射回路中，以减振系统 PID 控制器中的闭环控制量作为状态监测。闭环控制量能够反映系统的当前状态和控制效果，通过对其进行监测，可以及时了解系统的运行情况。将 DDPG 算法中动作网络的输出直接映射到 PID 参数区间，这样就实现了强化学习算法对 PID 参数的调整。通过这种方式，强化学习算法可以根据系统的状态和奖励信号，自动调整 PID 参数，以实现更好的控制效果。
- 并且可以根据奖励阈值，自动设定 PID 控制器的参考值。奖励阈值是一个衡量系统性能的指标，当系统的性能达到一定水平时，就可以认为系统处于一个较好的状态。通过自动设定参考值，可以使 PID 控制器在参考值的指导下进行参数的稳定探索。这种探索过程减少了对先验知识的依赖，使得系统能够更加自适应地调整参数，以适应不同的工作环境和任务要求。
减少先验知识依赖的优势
- 传统的 PID 控制器参数整定方法往往需要大量的先验知识和经验，而且在面对复杂的多自由度减振系统时，可能需要进行繁琐的调试和优化。而基于强化学习的方法则可以通过不断地与环境交互，自动学习最优的 PID 参数，无需过多的先验知识。这种方法能够更加灵活地适应不同的系统特性和工作条件，提高了系统的鲁棒性和适应性。同时，通过自动设定参考值和进行稳定探索，系统可以在不断的学习过程中逐渐优化参数，提高控制精度和稳定性。

（二）基于多阶段动作聚焦过程的强化学习算法（MF-DDPG）

解决 PID 控制不稳定问题的策略
- 针对强化学习算法中由于智能体随机探索引起的 PID 控制不稳定问题，提出了基于多阶段动作聚焦过程的强化学习算法 —MF-DDPG。在传统的强化学习算法中，智能体的随机探索可能会导致 PID 控制器的输出不稳定，从而影响减振系统的性能。为了解决这个问题，借鉴约束强化学习的理念，将 PID 参数输出在参考值约束在一定的区间内。通过这种方式，可以限制智能体的探索范围，避免其产生过大的输出变化，从而保证 PID 控制器的稳定性。
- 在动作奖励逐渐满足奖励阈值的过程中，智能体的动作空间受到约束，不断收敛至最优的参数空间。随着智能体与环境的交互，它会根据奖励信号不断调整自己的策略。当动作奖励逐渐满足奖励阈值时，说明系统的性能正在逐步提高。此时，通过约束智能体的动作空间，可以使其更加专注于优化 PID 参数，朝着最优的参数空间收敛。这样可以克服传统 DDPG 算法中随机探索引起的 PID 控制器输出不稳定问题，确保减振系统的稳定性。
提高算法通用性的方法
- 为了保证算法的通用性，针对主动减振系统的控制特点，对强化学习算法的环境、奖励、状态等要素进行了通用的定义。不同的减振系统可能具有不同的特性和工作条件，但它们也有一些共同的特点和需求。通过对强化学习算法的环境、奖励、状态等要素进行通用的定义，可以使算法适用于不同的减振系统，提高了算法的普遍适用性。例如，可以根据减振系统的振动幅度、频率等特征来定义状态空间，根据减振效果来定义奖励函数，从而使算法能够更好地适应不同的系统需求。

（三）嵌入残差结构的 MF-DDPG 改进算法及其实验验证

解决梯度消失问题的方法
- 针对强化学习智能体探索空间约束导致的梯度消失现象，提出了嵌入残差结构的 MF-DDPG 改进算法。在 DDPG 动作网络中，由于智能体的动作空间被约束，可能会导致梯度更新缓慢和梯度消失问题。为了解决这个问题，通过残差结构引出从神经网络浅层到深层的分支结构。这种分支结构可以使梯度在更新过程中更加顺畅地传递，避免了梯度消失的问题。同时，它还能够克服由于智能体动作空间被约束导致的梯度更新缓慢问题，保证了在动作网络梯度更新的过程中，梯度范围始终保持在合理区间。
提升算法性能与 PID 控制稳定性
- 该结构进一步提升了 MF-DDPG 算法性能与 PID 控制的稳定性，有效提高了本文减振控制问题方案的可靠性。通过嵌入残差结构，改进后的算法在性能上得到了显著提升。在保证 PID 控制器输出稳定性的同时，相比同类 PID 参数自适应整定算法，性能上提升了 16%-30%。这表明残差结构的引入有效地解决了梯度消失问题，提高了算法的学习效率和控制精度。
实验验证算法性能
- 为了验证 MF-DDPG 算法用于主动减振系统的控制性能，论文首先分别基于一阶和二阶典型 PID 控制系统设计了一系列实验对算法进行了验证。在上述两种系统上，嵌入残差结构的 MF-DDPG 改进算法性能表现优异。实验结果表明，该算法在保证了 PID 控制器输出稳定性的同时，能够有效地提高系统的减振性能。此外，本文在单自由度主动减振仿真系统以及等效六自由度 Stewart 减振数字样机上对减振算法开展了实验验证，针对减振系统的减振性能曲线、PID 跟踪误差、位移传递比等关键指标进行了分析。实验结果表明，嵌入残差结构的 MF-DDPG 控制方案能够在保证 PID 控制器稳定性的前提下，有效提升不同减振系统的减振性能，与领域内同类算法相比，隔振水平提升 30%-50% 以上，能够有效实现稳定可控的智能减振，为变化振动激励输入下的多自由度主动减振控制提供可用的技术支持。

import numpy as np

# 模拟环境状态
class Environment:
    def __init__(self):
        self.state = np.random.rand(5)  # 假设状态是一个 5 维向量
        self.target_state = np.zeros(5)
        self.pid_parameters = np.array([0.5, 0.1, 0.2])  # 假设初始 PID 参数

    def step(self, action):
        # 模拟环境对动作的响应，这里只是简单地更新状态
        new_state = self.state + action * 0.1
        reward = -np.sum(np.abs(new_state - self.target_state))
        done = False
        return new_state, reward, done

# 模拟智能体
class Agent:
    def __init__(self):
        self.action_space = np.array([-1, 1])
        self.state_dim = 5
        self.action_dim = 1
        self.policy_network = SimpleNeuralNetwork(self.state_dim, self.action_dim)
        self.target_network = SimpleNeuralNetwork(self.state_dim, self.action_dim)
        self.copy_weights()
        self.replay_buffer = []

    def act(self, state):
        state_tensor = torch.tensor(state, dtype=torch.float32).unsqueeze(0)
        action = self.policy_network(state_tensor).detach().numpy()[0][0]
        action = np.clip(action, self.action_space[0], self.action_space[1])
        return action

    def remember(self, state, action, reward, next_state, done):
        self.replay_buffer.append((state, action, reward, next_state, done))

    def learn(self):
        if len(self.replay_buffer) < min_replay_size:
            return
        batch = random.sample(self.replay_buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        states_tensor = torch.tensor(states, dtype=torch.float32)
        actions_tensor = torch.tensor(actions, dtype=torch.float32).unsqueeze(1)
        rewards_tensor = torch.tensor(rewards, dtype=torch.float32).unsqueeze(1)
        next_states_tensor = torch.tensor(next_states, dtype=torch.float32)
        dones_tensor = torch.tensor(dones, dtype=torch.float32).unsqueeze(1)

        with torch.no_grad():
            next_actions = self.target_network(next_states_tensor).detach()
            target_q_values = rewards_tensor + gamma * (1 - dones_tensor) * self.target_network(next_states_tensor).detach().max(1)[0].unsqueeze(1)

        q_values = self.policy_network(states_tensor).gather(1, actions_tensor.long())
        loss = nn.MSELoss()(q_values, target_q_values)

        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        # 更新目标网络
        if self.step_count % target_update_interval == 0:
            self.copy_weights()

        self.step_count += 1

# 简单的神经网络类
class SimpleNeuralNetwork(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(SimpleNeuralNetwork, self).__init__()
        self.fc1 = nn.Linear(input_dim, 32)
        self.fc2 = nn.Linear(32, output_dim)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.tanh(self.fc2(x))
        return x

# 训练主循环
env = Environment()
agent = Agent()
episodes = 1000
for episode in range(episodes):
    state = env.reset()
    done = False
    while not done:
        action = agent.act(state)
        next_state, reward, done = env.step(action)
        agent.remember(state, action, reward, next_state, done)
        agent.learn()
        state = next_state