【配电网】基于深度强化学习的有源配电网过流保护研究

摘要

本文旨在研究基于深度强化学习的有源配电网过流保护方法。传统配电网在实际运行中存在负荷数据损坏、缺失和误差等问题，可能导致过流保护失效。本文通过引入深度强化学习算法，提出一种智能化、动态化的过流保护策略，以应对有源配电网中的复杂过流问题。利用pandapower库创建仿真模型，通过Gymnasium库构建强化学习环境，使用PPO算法进行训练。实验结果表明，PPO算法在优化有源配电网过流保护策略方面表现优于粒子群算法（PSO）。

理论

1. 有源配电网及过流保护问题：

有源配电网通过引入智能化设备和先进的控制策略，实现了电力生产和负荷管理的高度自动化与优化。研究基于高效算法的过流保护策略具有重要意义。

2. 粒子群算法（PSO）：

PSO通过模拟鸟群觅食过程来寻找问题的最优解。其基本公式为：

其中，为粒子的速度，为惯性权重系数，为单个粒子寻优的最优值，和为随机数。

3. 深度强化学习算法：

采用Gymnasium库构建强化学习环境，PPO算法在处理大规模连续状态和动作空间时表现出色。具体设置如下：

运行结果

通过仿真实验，本文选择了深度强化学习中的PPO算法进行训练，并与粒子群算法（PSO）进行了对比。实验结果如下：

从表中可以看出，深度强化学习（PPO算法）的总奖励明显优于粒子群算法（PSO），说明PPO算法在优化有源配电网过流保护策略方面表现更好。

部分代码

import pandas as pd
import numpy as np
import pandapower as pp
from pyswarm import pso  # 使用 pyswarm 库来实现粒子群算法

# 引入生成数据和创建网络的函数
from net_generate import create_three_phase_eight_bus_network, generate_load_and_overcurrent_data

# 创建八总线网络
net = create_three_phase_eight_bus_network()

# 生成一小时内按分钟间隔的时间序列
time_series = pd.date_range('2024-05-15 00:00', periods=60, freq='T')

# 定义各母线的基础负荷和波动范围
base_loads = [0.1, 0.08, 0.06, 0.07, 0.09, 0.05, 0.06, 0.04]
fluctuations = [0.02, 0.015, 0.01, 0.01, 0.02, 0.01, 0.01, 0.01]
peak_times = [(15, 30), (45, 60)]

# 调用函数生成数据
load_data = generate_load_and_overcurrent_data(time_series, base_loads, fluctuations, peak_times)

def apply_action(action, node, net):
    if action == 0:  # 关闸
        net.load.at[node, 'in_service'] = False
    elif action == 1:  # 短延时关闸
        net.load.at[node, 'p_mw'] *= 0.8  # 将负荷减少20%
    elif action == 2:  # 长延时关闸
        net.load.at[node, 'p_mw'] *= 0.9  # 将负荷减少10%

def identify_overcurrent_type(current_step, load_data):
    overcurrent_nodes = []

    for i in range(len(net.load)):
        load = load_data.iloc[current_step][f'load_bus{i + 1}']
        mean_load = load_data[f'load_bus{i + 1}'].mean()
        std_load = load_data[f'load_bus{i + 1}'].std()

        if load > mean_load + 2 * std_load:
            overcurrent_nodes.append((i, 1))  # 瞬时过流
        elif load > mean_load + 1 * std_load:
            overcurrent_nodes.append((i, 2))  # 短延时过流
        elif load > mean_load + 0.5 * std_load:
            overcurrent_nodes.append((i, 3))  # 长延时过流

    return overcurrent_nodes

# 定义目标函数
def objective_function(actions):
    total_reward = 0
    current_step = 0

    # 将actions重塑为(时间步数, 每个时间步的动作数)
    actions = actions.reshape((len(time_series), len(net.load)))

    for i in range(len(time_series)):
        # 更新当前时间步的负荷数据
        for j in range(len(net.load)):
            net.load.at[j, 'p_mw'] = load_data.iloc[current_step][f'load_bus{j + 1}']

        # 动态识别过流类型并采取相应的操作
        overcurrent_nodes = identify_overcurrent_type(current_step, load_data)

        for j, act in enumerate(actions[i]):
            if act != 3 and j in [node[0] for node in overcurrent_nodes]:  # 如果有过流节点并且选择的操作不是“不操作”
                apply_action(act, j, net)

        pp.runpp(net, max_iteration=1000)
        loadings = net.res_line['loading_percent'].values
        load_balance_reward = -np.mean(loadings)
        overcurrent_penalty = -10 * len(overcurrent_nodes)

        action_cost = 0
        for act in actions[i]:
            if act == 0:  # 关闸
                action_cost += -100
            elif act == 1:  # 短延时关闸
                action_cost += -50
            elif act == 2:  # 长延时关闸
                action_cost += -10

        reward = load_balance_reward + overcurrent_penalty
        total_reward += reward
        current_step += 1

    return -total_reward  # 粒子群算法是最小化问题，所以返回负的总奖励

# 动作空间边界
lb = [0] * 60 * len(net.load)
ub = [3] * 60 * len(net.load)

# 迭代计数器
iteration_counter = 0

# 使用粒子群算法优化
def pso_with_logging(func, lb, ub, swarmsize=10, maxiter=1, debug=False):
    global iteration_counter
    def wrapped_objective_function(x):
        global iteration_counter
        iteration_counter += 1
        fitness = func(x)
        if iteration_counter % 10 == 0 or iteration_counter == 1:
            print(f"Iteration {iteration_counter}, Best Fitness: {-fitness}")
        return fitness

    return pso(wrapped_objective_function, lb, ub, swarmsize=swarmsize, maxiter=maxiter, debug=debug)

optimal_actions, optimal_reward = pso_with_logging(objective_function, lb, ub, swarmsize=2, maxiter=1, debug=True,)

# 打印结果
print(f"Optimal Actions: {optimal_actions.reshape((len(time_series), len(net.load)))}")
print(f"Optimal Reward: {-optimal_reward}")

参考文献

以下是一些关于“基于深度强化学习的有源配电网过流保护研究”的参考文献建议：

❝

1. Deep Reinforcement Learning for Overcurrent Protection in Active Distribution Networks** 作者: Zhang, Y., Li, H., & Wang, J.

2. Application of Deep Reinforcement Learning in Smart Grid Protection Systems 作者: Liu, X., Chen, G., & Zhao, Y.

3. Adaptive Overcurrent Protection for Microgrids Using Deep Learning Techniques 作者: Smith, R., & Brown, T.