基于DDPG算法的发电公司竞价策略代码逐逐段解读说明

发电公司（智能体）通过DDPG算法学习竞价参数α电力市场环境（threebus.py或thirtybus.py）根据竞价参数进行市场出清计算节点电价和发电公司利润，将利润作为奖励反馈给智能体智能体通过经验回放和 Actor-Critic 架构更新策略经过多轮迭代，智能体逐渐收敛到最优竞价策略通过与理论纳什均衡和其他算法（Q-Learning、VRE）对比，验证DDPG算法的有效性程序设计遵循模块化

2501_93693767

1513人浏览 · 2025-10-26 08:15:00

2501_93693767 · 2025-10-26 08:15:00 发布

python代码：基于DDPG（深度确定性梯度策略）算法的售电公司竞价策略研究关键词：DDPG 算法深度强化学习电力市场发电商竞价说明文档：完美复现英文文档，可找我看文档主要内容：代码主要研究的是多个售电公司的竞标以及报价策略，属于电力市场范畴，目前常用博弈论方法寻求电力市场均衡，但是此类方法局限于信息完备的简单市场环境，难以直观地反映竞争性的市场环境，因此，本代码通过深度确定性梯度策略算法（DDPG）对发电公司的售价进行建模，解决了传统的RL算法局限于低维离散状态空间和行为空间，收敛性不稳的问题，实验表明，该方法比传统的RL算法具有更高的精度，即使在不完全信息环境下也能收敛到完全信息的纳什均衡。此外，该方法通过定量调整发电商的耐心参数，可以直观地反映不同的默契合谋程度，是分析市场策略的有效手段。目前深度强化学习非常火热，很容易出成果，非常适合在本代码的基础上稍微加点东西，即可形成自己的成果，非常适合深度强化学习方向的人学习！这段代码包含了三个程序，我们分别来进行详细分析。程序一： ```python import numpy as np from market.three_bus import market_clearing from algorithm.VRE import RothErevAgents import matplotlib.pyplot as plt n_agents = 2 action_space = np.arange(0, 3.1, 0.2) n_steps = 10000 a_real = np.array([15.0, 18.0]) strategic_variables = np.zeros((n_steps, n_agents)) multi_agents = RothErevAgents(n_agents, action_space) for step in range(n_steps): action = multi_agents.select_action() alpha = action * a_real nodal_price, profit = market_clearing(alpha) strategic_variables[step] = alpha multi_agents.learn(profit) if (step + 1) % 1000 == 0: print('Step:', step + 1, 'a1: %.2f' % alpha[0], 'a2: %.2f' % alpha[1], 'r1: %.3f' % profit[0], 'r2: %.3f' % profit[1]) C = np.array([[0.36, 0.58, 0.75], [0.92, 0.28, 0.29]]) plt.plot(strategic_variables[:, 0], lw=0.5, C=C[0], alpha=0.5, label=r"$\alpha_{1t}$") plt.plot(strategic_variables[:, 1], lw=0.5, C=C[1], alpha=0.5, label=r"$\alpha_{2t}$") plt.plot([0, 10000], [20.29, 20.29], '--', C=C[0], label=r"$\alpha_{1t}^\ast$") plt.plot([0, 10000], [22.98, 22.98], '--', C=C[1], label=r"$\alpha_{2t}^\ast$") plt.xlabel(r"$t$") plt.ylabel(r"$\alpha_{gt}$ (\$/MHh)") plt.title("VRE (3-Bus System)") plt.legend() plt.savefig('VRE.png', dpi=600) plt.show() ``` 这段代码主要是使用了RothErevAgents算法来进行市场交易的仿真。程序首先导入了一些必要的库，然后定义了一些变量，包括代理数量（n_agents）、动作空间（action_space）、仿真步数（n_steps）和真实的动作值（a_real）。接下来，创建了一个RothErevAgents对象（multi_agents），该对象使用Roth-Erev算法来选择动作。在每个步骤中，程序通过调用multi_agents.select_action()来选择动作。然后，根据选择的动作和真实的动作值计算alpha值。接着，使用market_clearing函数计算节点价格和利润。将alpha值存储在strategic_variables数组中，并使用multi_agents.learn()函数来更新代理的策略。在每1000个步骤后，程序会打印出当前步骤数、alpha值和利润。最后，程序使用matplotlib库绘制了两个alpha值随时间变化的图形，并保存为图片。程序二和程序三的结构与程序一类似，只是使用了不同的算法（QLearning和DDPG）和模型（ANet2和CNet2）。它们的功能和工作方式与程序一类似，只是算法和模型的不同。

一、核心算法模块（DDPG.py）

1.1 DDPG类初始化

class DDPG(object):
    def __init__(self, a_dim, s_dim, a_bound,):
        self.a_dim, self.s_dim, self.a_bound = a_dim, s_dim, a_bound[1]
        self.memory = np.zeros((MEMORY_CAPACITY, s_dim * 2 + a_dim + 1), dtype=np.float32)
        self.pointer = 0
        self.sess = tf.Session()
        self.actor_eval = self._build_actor_net('actor_eval', trainable=True)
        self.actor_target = self._build_actor_net('actor_target', trainable=False)
        self.critic_eval = self._build_critic_net('critic_eval', trainable=True)
        self.critic_target = self._build_critic_net('critic_target', trainable=False)

该部分初始化DDPG算法的核心组件：

定义动作维度（adim）、状态维度（sdim）和动作边界（a_bound）
创建经验回放缓冲区（memory），用于存储智能体与环境的交互数据
构建Actor-Critic架构的四个神经网络：评估网络（actoreval、criticeval）和目标网络（actortarget、critictarget）
评估网络用于实时决策和参数更新，目标网络用于计算目标Q值，提高训练稳定性

1.2 神经网络构建

def _build_actor_net(self, name, trainable):
    with tf.variable_scope(name):
        s = tf.placeholder(tf.float32, [None, self.s_dim], 's')
        x = tf.layers.dense(s, 30, activation=tf.nn.relu, name='l1', trainable=trainable)
        a = tf.layers.dense(x, self.a_dim, activation=tf.nn.tanh, name='a', trainable=trainable)
        return tf.multiply(a, self.a_bound, name='scaled_a'), s

def _build_critic_net(self, name, trainable):
    with tf.variable_scope(name):
        s = tf.placeholder(tf.float32, [None, self.s_dim], 's')
        a = tf.placeholder(tf.float32, [None, self.a_dim], 'a')
        w1_s = tf.get_variable('w1_s', [self.s_dim, 30], trainable=trainable)
        w1_a = tf.get_variable('w1_a', [self.a_dim, 30], trainable=trainable)
        b1 = tf.get_variable('b1', [1, 30], trainable=trainable)
        x = tf.nn.relu(tf.matmul(s, w1_s) + tf.matmul(a, w1_a) + b1)
        q = tf.layers.dense(x, 1, trainable=trainable)
        return q, s, a

Actor网络：输入状态s，通过全连接层（30个神经元）和ReLU激活函数，输出经过tanh激活并缩放的动作值
Critic网络：联合输入状态s和动作a，通过全连接层计算Q值，评估当前动作的价值
采用分开的权重参数确保网络独立性，支持不同的训练策略

1.3 动作选择与经验存储

def choose_action(self, s):
    return self.sess.run(self.actor_eval[0], {self.actor_eval[1]: s[np.newaxis, :]})[0]

def store_transition(self, s, a, r, s_):
    transition = np.hstack((s, a, [r], s_))
    index = self.pointer % MEMORY_CAPACITY
    self.memory[index, :] = transition
    self.pointer += 1

choose_action：根据当前状态s，通过Actor评估网络生成动作
storetransition：将状态(s)、动作(a)、奖励(r)和下一状态(s)存储到经验回放缓冲区
采用循环缓冲区机制，当存储满时自动覆盖最早的经验数据

1.4 学习过程

def learn(self):
    self.sess.run(self.soft_replace)
    indices = np.random.choice(MEMORY_CAPACITY, size=BATCH_SIZE)
    bt = self.memory[indices, :]
    bs = bt[:, :self.s_dim]
    ba = bt[:, self.s_dim:self.s_dim+self.a_dim]
    br = bt[:, -self.s_dim-1:-self.s_dim]
    bs_ = bt[:, -self.s_dim:]

    a_ = self.sess.run(self.actor_target[0], {self.actor_target[1]: bs_})
    q_ = self.sess.run(self.critic_target[0], {self.critic_target[1]: bs_, self.critic_target[2]: a_})
    q_target = br + GAMMA * q_
    self.sess.run(self.critic_train, {self.critic_eval[1]: bs, self.critic_eval[2]: ba, self.critic_eval[3]: q_target})
    a_loss = -self.sess.run(self.critic_eval[0], {self.critic_eval[1]: bs, self.critic_eval[2]: self.sess.run(self.actor_eval[0], {self.actor_eval[1]: bs})})
    self.sess.run(self.actor_train, {self.actor_eval[1]: bs})

学习过程实现：

软更新目标网络参数（通过预定义的soft_replace操作）
从经验缓冲区随机采样批量数据（BATCH_SIZE）
分离状态、动作、奖励和下一状态数据
计算目标Q值：基于下一状态的目标动作和目标Q值，结合奖励和折扣因子
训练Critic网络：最小化预测Q值与目标Q值的均方误差
训练Actor网络：通过策略梯度上升最大化Critic评估的Q值

二、电力系统模型（three_bus.py）

2.1 市场出清函数

def market_clearing(alpha1, alpha2):
    # 发电公司成本参数
    a1 = 15.0; a2 = 18.0
    beta1 = 0.05; beta2 = 0.06
    pmax1 = 100; pmax2 = 100
    pmin1 = 0; pmin2 = 0
    
    # 负荷参数
    D1 = 80; D2 = 70
    fd1 = 0.03; fd2 = 0.04
    
    # 线路参数
    Fmax = 25  # 线路1-2传输容量限制
    
    # 构建二次规划问题
    P = matrix([[2*beta1, 0., 0., 0.],
                [0., 2*beta2, 0., 0.],
                [0., 0., 2*fd1, 0.],
                [0., 0., 0., 2*fd2]])
    q = matrix([-alpha1, -alpha2, D1/fd1, D2/fd2])
    
    # 约束条件
    G = matrix([[1., 0., -1., 0.],
                [-1., 0., 1., 0.],
                [0., 1., 0., -1.],
                [0., -1., 0., 1.],
                [1., 1., -1., -1.],
                [-1., -1., 1., 1.]])
    h = matrix([Fmax, Fmax, Fmax, Fmax, 0., 0.])
    
    # 变量上下限
    A = matrix([[1., 0., 0., 0.], [0., 1., 0., 0.]])
    b = matrix([pmax1, pmax2])
    Aeq = matrix([[0., 0., 1., 0.], [0., 0., 0., 1.]])
    beq = matrix([0., 0.])
    
    # 求解
    sol = solvers.qp(P, q, G, h, A, b)
    result = sol['x']
    
    # 计算节点电价和利润
    lambda1 = alpha1 - 2*beta1*result[0] + 2*fd1*result[2]
    lambda2 = alpha2 - 2*beta2*result[1] + 2*fd2*result[3]
    profit1 = (lambda1 - (a1 + beta1*result[0])) * result[0]
    profit2 = (lambda2 - (a2 + beta2*result[1])) * result[1]
    
    return lambda1, lambda2, profit1, profit2

该函数实现3节点电力系统的市场出清过程：

定义发电公司参数：成本系数（a1,a2,beta1,beta2）、出力上下限（pmax,pmin）
定义负荷参数：基础需求（D1,D2）、需求弹性系数（fd1,fd2）
设置线路传输容量限制（Fmax=25MW）
构建二次规划模型，目标函数为社会福利最大化
添加功率平衡、线路潮流、出力限制等约束条件
使用cvxopt求解器求解优化问题
计算节点电价和各发电公司利润
返回节点电价和利润作为环境反馈

三、主运行程序（run_DDPG_3-bus.py）

3.1 初始化设置

import numpy as np
import matplotlib.pyplot as plt
from DDPG import DDPG
from three_bus import market_clearing

# 参数设置
MAX_EPISODES = 10000
MAX_EP_STEPS = 1
a_dim = 1
s_dim = 2
a_bound = [-1, 1]

# 初始化DDPG智能体
agent1 = DDPG(a_dim, s_dim, a_bound)
agent2 = DDPG(a_dim, s_dim, a_bound)

# 存储结果
alpha1_history = []
alpha2_history = []
profit1_history = []
profit2_history = []

主程序初始化：

设置训练参数：最大 episode 数（10000）、每个 episode 的步数（1）
定义动作维度（1）和状态维度（2，对应两个节点电价）
创建两个DDPG智能体，分别代表两家发电公司
初始化历史记录列表，存储竞价参数和利润变化

3.2 训练过程

for i in range(MAX_EPISODES):
    # 初始状态（节点电价）
    s = np.array([20.0, 25.0])  # 初始节点电价
    
    # 探索噪声
    var = max(0.02, 1 - i/MAX_EPISODES)
    
    # 选择动作
    a1 = agent1.choose_action(s)
    a2 = agent2.choose_action(s)
    a1 = np.clip(np.random.normal(a1, var), -1, 1)
    a2 = np.clip(np.random.normal(a2, var), -1, 1)
    
    # 动作映射到实际竞价参数
    alpha1 = (a1 + 1) * 15 * 1.5  # 映射到0-45范围
    alpha2 = (a2 + 1) * 18 * 1.5  # 映射到0-54范围
    
    # 市场出清
    lambda1, lambda2, profit1, profit2 = market_clearing(alpha1, alpha2)
    s_ = np.array([lambda1, lambda2])
    
    # 奖励
    r1 = profit1 / 1000.0
    r2 = profit2 / 1000.0
    
    # 存储经验
    agent1.store_transition(s, a1, r1, s_)
    agent2.store_transition(s, a2, r2, s_)
    
    # 学习
    if i > MEMORY_CAPACITY:
        agent1.learn()
        agent2.learn()
    
    # 记录历史
    alpha1_history.append(alpha1)
    alpha2_history.append(alpha2)
    profit1_history.append(profit1)
    profit2_history.append(profit2)
    
    # 打印信息
    if i % 1000 == 0:
        print('Episode:', i, 'alpha1:', alpha1, 'alpha2:', alpha2, 'profit1:', profit1, 'profit2:', profit2, 'var:', var)

训练循环实现：

初始化状态为初始节点电价
动态调整探索噪声（随训练进程衰减）
智能体选择动作并添加探索噪声
将动作映射到实际竞价参数范围（alpha1:0-45, alpha2:0-54）
调用市场出清函数获取新状态（节点电价）和奖励（利润）
存储经验并在缓冲区满后开始学习
记录历史数据并定期打印训练进度

3.3 结果可视化

# 绘制竞价参数曲线
plt.figure()
plt.plot(alpha1_history, label='Generator 1 alpha')
plt.plot(alpha2_history, label='Generator 2 alpha')
plt.axhline(y=20.29, color='r', linestyle='--', label='Nash Equilibrium G1')
plt.axhline(y=22.98, color='g', linestyle='--', label='Nash Equilibrium G2')
plt.xlabel('Episode')
plt.ylabel('Alpha')
plt.legend()
plt.title('DDPG Bidding Strategy in 3-bus System')
plt.savefig('DDPG_3_bus.png')
plt.show()

可视化部分：