✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

 ✅ 具体问题可以私信或扫描文章底部二维码。

（1）为了克服传统路由协议在面对现代网络复杂动态环境时暴露出的种种弊端，如收敛缓慢、无法感知全局网络状态以及策略僵化等问题，我们提出并设计了一种基于集中式控制的智能路由架构。该架构的核心思想是将网络的控制平面与数据平面分离，通过一个中心化的控制器来收集全局网络信息并制定最优的路由策略。我们设计的智能路由架构在逻辑上分为三层：数据平面、控制平面和应用平面。数据平面由网络中的交换机和路由器等基础设施构成，它们负责根据控制平面下发的流表规则进行高速的数据包转发。这一层被简化为纯粹的执行单元，不再承担复杂的路由计算任务。控制平面是整个架构的大脑，它运行在一个或一组强大的服务器上，通过OpenFlow等南向接口协议与数据平面的设备进行通信，从而能够实时地收集全网的拓扑结构、链路带宽、时延、丢包率等状态信息。最关键的创新在于，我们在控制平面中引入了深度强化学习（DRL）算法模块。这个模块将整个网络视为一个环境（Environment），网络的状态（如流量矩阵、链路负载等）是DRL智能体（Agent）的输入。智能体的动作（Action）则是生成并下发新的路由策略（例如，为特定的数据流选择一条最优路径）。每次动作执行后，网络会产生一个新的状态，并根据预设的性能指标（如平均时延、吞吐量）计算出一个奖励（Reward）值反馈给智能体。通过不断的“试错”与学习，DRL智能体能够学习到一个从网络状态到最优路由动作的映射策略（Policy），从而实现路由策略的动态、按需生成。应用平面则位于最顶层，它为网络管理员提供了配置接口，用于定义上层的业务需求和优化目标（例如，优先保障视频会议的低时延，或最大化文件传输的吞吐量），这些目标将被转化为DRL模块中的奖励函数。通过这种三层逻辑结构，我们构建了一个能够从历史经验中学习并自主优化的闭环控制系统，它能够根据实时的网络性能指标动态调整路由，从而实现网络资源的合理化、精细化分配，极大地提升了网络的整体性能和适应性。

（22）在构建了集中式智能路由架构的基础上，我们针对网络状态空间连续且复杂的特性，设计并实现了一种名为DDPGOR（Deep Deterministic Policy Gradient on Routing）的路由优化算法。该算法基于深度确定性策略梯度（DDPG），这是一种适用于连续动作空间的Actor-Critic框架的深度强化学习算法。在我们的路由优化场景中，网络的状态（如各链路的实时负载率、时延等）构成了一个高维的连续状态空间，而路由决策（如为数据流在多条可选路径上分配流量的比例）也构成了一个连续的动作空间。DDPGOR算法包含两个核心的神经网络：Actor网络和Critic网络。Actor网络负责学习策略函数，它的输入是当前的网络状态，输出是一个确定性的路由动作。Critic网络则负责学习动作价值函数（Q函数），它的输入是网络状态和Actor网络输出的动作，输出是对该状态-动作对的评价值（Q值），用于指导Actor网络的更新。为了提升学习的稳定性和效率，我们采用了经验回放（Experience Replay）机制，将智能体与环境交互产生的大量样本（状态、动作、奖励、下一状态）存储在一个经验池中，每次更新网络时从中随机采样一个小批量（mini-batch）进行训练，打破了样本之间的相关性。同时，我们还引入了目标网络（Target Network）技术，为Actor和Critic网络分别创建了一个结构相同但参数更新缓慢的目标网络，用于在计算TD误差时提供一个稳定的目标值，有效避免了训练过程中的震荡。然而，DDPG算法本身存在Q值过高估计的问题，可能导致策略学习效果不佳。为了解决这一不足，我们进一步引入了其改进版本——双延迟深度确定性策略梯度（TD3）算法，并设计了相应的TD3OR（Twin Delayed Deep Deterministic Policy Gradient on Routing）算法。TD3OR通过三个关键技术对DDPGOR进行了优化：首先，它构建了两个独立的Critic网络（Twin Critics），在计算Q目标值时取两者中的较小值，从而有效抑制了Q值的过高估计；其次，它采用了延迟策略更新（Delayed Policy Updates），即Actor网络的更新频率低于Critic网络，确保在策略更新前Q函数已经得到了较为充分的收敛；最后，它在计算目标Q值时对目标策略的动作加入了噪声，起到了平滑Q函数的作用。通过在模拟网络环境中的大量仿真实验，结果表明，DDPGOR和TD3OR相较于OSPF等传统路由算法，均能显著降低端到端时延，提升网络吞吐量和链路利用率。并且，作为优化版本的TD3OR，在收敛速度、稳定性以及各项性能指标上均全面优于DDPGOR，展现出更强的路由优化能力。

（3）现代计算机网络中，存在大量具有明显周期性规律的流量，例如企业在工作时间内的办公流量、夜间的备份流量以及视频网站晚间高峰期的流媒体流量等。传统的强化学习算法通常只关注当前时刻的网络状态，缺乏对这种时间序列特征的捕捉和预测能力，因而难以制定出具有前瞻性的最优路由策略。为了有效应对周期性流量带来的挑战，我们提出了一种名为DRDPGOR（Deep Recurrent Deterministic Policy Gradient on Routing）的路由优化算法。该算法的核心创新在于将长短期记忆网络（LSTM）深度融合到DDPG框架中。具体而言，我们在Actor网络和Critic网络的输入层之后，引入了LSTM层。LSTM作为一种特殊的循环神经网络（RNN），能够通过其内部的门控机制（输入门、遗忘门、输出门）有效地学习和记忆时间序列数据中的长期依赖关系。这样，DRDPGOR的智能体在做决策时，不仅仅依赖于当前瞬时的网络状态，而是能够综合考虑过去一段时间内的网络状态序列，从而捕捉到流量的周期性模式，并对未来短时间内的流量趋势做出隐式的预测。为了进一步增强模型对关键时间步信息的关注度，我们还在LSTM层之后加入了注意力机制（Attention Mechanism）。注意力机制能够动态地为输入序列中的不同时间步分配不同的权重，使得模型在决策时能够更加关注那些对当前路由决策影响最大的历史状态信息，忽略次要信息，从而提高预测的准确性和决策的质量。在DRDPGOR的基础上，为了更全面地捕捉时间序列的双向依赖关系（即未来的状态也可能为理解当前状态提供信息），我们进一步设计了一种更为先进的Bi-DRDPGOR（Bidirectional DRDPGOR）算法。该算法将Actor网络中的单向LSTM替换为双向长短期记忆网络（Bi-LSTM）。Bi-LSTM由一个前向LSTM和一个后向LSTM组成，能够同时从过去和未来两个方向上提取序列信息，从而获得对流量模式更深刻、更完整的理解。仿真实验在一个具有明显周期性流量特征的网络环境中进行，实验结果清晰地表明，DRDPGOR和Bi-DRDPGOR算法相比于不具备时序信息处理能力的DDPGOR和TD3OR，能够生成更优的路由策略，显著降低了网络在流量高峰期的平均时延和丢包率。其中，Bi-DRDPGOR由于其更强大的时序特征提取能力，在各项性能指标上均表现最佳，充分证明了我们所提出的算法在处理周期性网络流量时的有效性和优越性。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import random
from collections import deque

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim, max_action):
        super(Actor, self).__init__()
        self.layer_1 = nn.Linear(state_dim, 400)
        self.layer_2 = nn.Linear(400, 300)
        self.layer_3 = nn.Linear(300, action_dim)
        self.max_action = max_action

    def forward(self, x):
        x = torch.relu(self.layer_1(x))
        x = torch.relu(self.layer_2(x))
        x = self.max_action * torch.tanh(self.layer_3(x))
        return x

class Critic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Critic, self).__init__()
        self.layer_1 = nn.Linear(state_dim + action_dim, 400)
        self.layer_2 = nn.Linear(400, 300)
        self.layer_3 = nn.Linear(300, 1)

    def forward(self, x, u):
        xu = torch.cat([x, u], 1)
        x = torch.relu(self.layer_1(xu))
        x = torch.relu(self.layer_2(x))
        x = self.layer_3(x)
        return x

class ReplayBuffer:
    def __init__(self, max_size=1e6):
        self.storage = deque(maxlen=int(max_size))

    def add(self, transition):
        self.storage.append(transition)

    def sample(self, batch_size):
        return random.sample(self.storage, batch_size)

class DDPG:
    def __init__(self, state_dim, action_dim, max_action):
        self.actor = Actor(state_dim, action_dim, max_action)
        self.actor_target = Actor(state_dim, action_dim, max_action)
        self.actor_target.load_state_dict(self.actor.state_dict())
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=1e-4)

        self.critic = Critic(state_dim, action_dim)
        self.critic_target = Critic(state_dim, action_dim)
        self.critic_target.load_state_dict(self.critic.state_dict())
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)

        self.replay_buffer = ReplayBuffer()
        self.max_action = max_action
        self.discount = 0.99
        self.tau = 0.005

    def select_action(self, state):
        state = torch.FloatTensor(state.reshape(1, -1))
        return self.actor(state).cpu().data.numpy().flatten()

    def train(self, batch_size=100):
        if len(self.replay_buffer.storage) < batch_size:
            return

        batch = self.replay_buffer.sample(batch_size)
        state, action, reward, next_state, done = map(torch.FloatTensor, zip(*batch))

        target_Q = self.critic_target(next_state, self.actor_target(next_state))
        target_Q = reward.unsqueeze(1) + (self.discount * target_Q * (1 - done.unsqueeze(1))).detach()
        
        current_Q = self.critic(state, action)
        critic_loss = nn.MSELoss()(current_Q, target_Q)
        
        self.critic_optimizer.zero_grad()
        critic_loss.backward()
        self.critic_optimizer.step()

        actor_loss = -self.critic(state, self.actor(state)).mean()
        
        self.actor_optimizer.zero_grad()
        actor_loss.backward()
        self.actor_optimizer.step()

        for param, target_param in zip(self.critic.parameters(), self.critic_target.parameters()):
            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)

        for param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):
            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)

# --- Simplified Network Environment ---
class NetworkEnv:
    def __init__(self, num_nodes=5):
        self.num_nodes = num_nodes
        self.state_dim = num_nodes * num_nodes # Traffic matrix
        self.action_dim = num_nodes * num_nodes # Routing policy (simplified)
        self.max_action = 1.0

    def reset(self):
        # Return a random traffic matrix
        return np.random.rand(self.state_dim)

    def step(self, action):
        # Simplified step logic
        # Reward is higher for actions that balance load (e.g., lower variance)
        latency = np.mean(action) + np.random.rand() * 0.1
        throughput = 1 / (latency + 1e-5)
        reward = throughput - 0.5 * np.std(action)
        next_state = self.reset() # New traffic demand
        done = False
        return next_state, reward, done

if __name__ == '__main__':
    env = NetworkEnv()
    agent = DDPG(env.state_dim, env.action_dim, env.max_action)

    max_episodes = 100
    max_steps = 50

    for episode in range(max_episodes):
        state = env.reset()
        episode_reward = 0
        for step in range(max_steps):
            action = agent.select_action(state)
            action = action + np.random.normal(0, 0.1, size=env.action_dim)
            action = action.clip(-env.max_action, env.max_action)
            
            next_state, reward, done = env.step(action)
            agent.replay_buffer.add((state, action, reward, next_state, float(done)))
            agent.train()
            
            state = next_state
            episode_reward += reward
        
        print(f"Episode: {episode+1}, Total Reward: {episode_reward:.2f}")

如有问题，可以直接沟通

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇