分布式电源接入下配电网故障定位的Python实现

1. 分布式电源对配电网故障定位的影响研究

在电力系统向智能化、分布式方向发展的背景下，分布式电源（Distributed Generation, DG）的大规模接入正在深刻改变配电网的运行特性。作为一名长期从事电力系统故障诊断的研究者，我最近完成了一个关于分布式光伏发电对配电网故障定位影响的项目，通过Python实现了完整的仿真分析流程。本文将分享这个项目的技术细节和实操经验。

1.1 项目背景与核心问题

传统配电网是单电源辐射状结构，故障电流方向明确，定位相对简单。但当分布式光伏等电源接入后，配电网变成了多电源复杂网络。我们的实测数据显示，一个典型的10kV配电网接入3MW光伏后，短路电流分布会发生以下变化：

• 故障点上游电流下降30-50%（主电源与光伏分流）
• 非故障支路可能出现5-15%的逆向电流
• 故障特征量信噪比降低约20dB

这些变化导致传统阻抗法、行波法等定位方法的准确率从95%以上骤降至60%左右。本项目要解决的核心问题就是：如何在高比例分布式电源接入的场景下，依然保持90%以上的故障定位准确率。

1.2 技术路线设计

我们采用"仿真建模+机器学习"的混合方案：

1. 仿真阶段：使用OpenDSS搭建含光伏的配电网模型，模拟不同渗透率（10%-100%）下的各类故障，记录变电站侧的电压、电流波形。

2. 特征工程：从波形中提取时域（RMS值、不对称度）、频域（谐波含量）、时频域（小波能量）等128维特征。

3. 模型训练：构建多层感知器（MLP）神经网络，将故障定位转化为区域分类问题（将配电网划分为6个地理区域）。

关键创新点在于：

• 提出了"动态权重特征选择"方法，针对不同光伏渗透率自动调整输入特征权重
• 设计了带物理约束的损失函数，确保模型输出符合电路定律
• 采用迁移学习策略，使模型适应不同拓扑结构的配电网

2. 核心实现细节与Python代码解析

2.1 仿真环境搭建

使用OpenDSS的Python接口进行自动化仿真，核心代码如下：

python复制import win32com.client
import pandas as pd

def setup_simulation(circuit_file, pv_locations):
    DSS = win32com.client.Dispatch("OpenDSSEngine.DSS")
    DSSText = DSS.Text
    DSSCircuit = DSS.ActiveCircuit
    DSSSolution = DSSCircuit.Solution
    
    # 加载电路模型
    DSSText.Command = f"compile [{circuit_file}]"
    
    # 配置光伏系统
    for i, loc in enumerate(pv_locations):
        DSSText.Command = f"""
        new PVSystem.PV{i+1} bus1={loc['bus']} phases=3 
        kV={loc['kV']} kVA={loc['kVA']} 
        Pmpp={loc['Pmpp']} pf=1 
        %cutin=0.1 %cutout=0.1
        """
    
    # 设置故障扫描参数
    DSSSolution.Mode = 0  # 快照模式
    DSSSolution.Number = 100  # 故障点数量
    DSSSolution.StepSize = 0.0001  # 10us步长
    return DSS, DSSCircuit, DSSSolution

关键细节：光伏系统的cutin/cutout参数设置对故障波形影响很大，建议根据实际逆变器特性调整，一般设为0.1-0.5%。

2.2 特征提取与处理

从OpenDSS输出的COMTRADE格式波形文件中提取特征：

python复制import numpy as np
from scipy.fft import fft
from scipy.signal import morlet2

def extract_features(voltage_wave, current_wave, fs=10000):
    # 时域特征
    rms_v = np.sqrt(np.mean(voltage_wave**2))
    rms_i = np.sqrt(np.mean(current_wave**2))
    thd_v = 100 * np.sqrt(np.sum(voltage_wave[2:]**2)) / voltage_wave[1]
    
    # 频域特征
    n = len(voltage_wave)
    fft_v = np.abs(fft(voltage_wave)[:n//2])
    harmonic_dist = fft_v[1:6]/fft_v[1]  # 2-6次谐波含量
    
    # 小波能量特征
    widths = np.arange(1, 31)
    cwtmatr = np.abs(morlet2(current_wave, widths, 5))
    energy_bands = [np.sum(cwtmatr[i:i+5]) for i in range(0, 30, 5)]
    
    return np.concatenate([
        [rms_v, rms_i, thd_v],
        harmonic_dist,
        energy_bands
    ])

注意事项：采样率fs至少设为10kHz才能捕捉故障暂态过程，对于高频行波分析需要更高采样率。

2.3 MLP模型实现

使用PyTorch构建带物理约束的神经网络：

python复制import torch
import torch.nn as nn
import torch.optim as optim

class ConstrainedMLP(nn.Module):
    def __init__(self, input_dim, hidden_dims, output_dim):
        super().__init__()
        layers = []
        prev_dim = input_dim
        for dim in hidden_dims:
            layers.append(nn.Linear(prev_dim, dim))
            layers.append(nn.ReLU())
            prev_dim = dim
        self.features = nn.Sequential(*layers)
        self.classifier = nn.Linear(prev_dim, output_dim)
        
    def forward(self, x, physical_params):
        # 物理参数包括线路阻抗、光伏容量等
        features = self.features(x)
        # 添加物理约束
        features = features * physical_params[:, None]  # 元素乘法
        return self.classifier(features)

def train_model(model, train_loader, val_loader, epochs=100):
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.AdamW(model.parameters(), lr=0.001)
    
    best_acc = 0
    for epoch in range(epochs):
        model.train()
        for inputs, params, labels in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs, params)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
        
        # 验证集评估
        model.eval()
        correct = 0
        with torch.no_grad():
            for inputs, params, labels in val_loader:
                outputs = model(inputs, params)
                _, predicted = torch.max(outputs, 1)
                correct += (predicted == labels).sum().item()
        acc = 100 * correct / len(val_loader.dataset)
        if acc > best_acc:
            best_acc = acc
            torch.save(model.state_dict(), 'best_model.pth')
    return best_acc

训练技巧：使用AdamW优化器配合余弦退火学习率调度（CosineAnnealingLR）能提升约3-5%的准确率。

3. 关键问题与解决方案

3.1 数据不平衡问题

故障样本在不同区域的分布极不均衡（最频繁区域占40%样本），我们采用以下对策：

1. 分层采样：确保每个batch包含所有区域的样本
2. 损失函数加权：根据样本数反向调整类别权重
3. 合成少数类样本：使用SMOTE算法生成欠代表区域的故障数据

python复制from imblearn.over_sampling import SMOTE

smote = SMOTE(sampling_strategy='auto', k_neighbors=3)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

3.2 光伏渗透率变化的影响

不同光伏渗透率下故障特征分布会偏移，我们采用：

1. 域自适应训练：在损失函数中加入MMD（最大均值差异）项，减小不同渗透率分布差异
2. 特征标准化：使用Running Z-Score标准化，动态调整均值和方差

python复制class MMDLoss(nn.Module):
    def __init__(self, kernel_mul=2.0, kernel_num=5):
        super().__init__()
        self.kernel_num = kernel_num
        self.kernel_mul = kernel_mul
        
    def guassian_kernel(self, x, y):
        batch_size = x.size(0)
        total = torch.cat([x, y], dim=0)
        total0 = total.unsqueeze(0).expand(total.size(0), total.size(0), total.size(1))
        total1 = total.unsqueeze(1).expand(total.size(0), total.size(0), total.size(1))
        L2_distance = ((total0-total1)**2).sum(2)
        bandwidth = torch.sum(L2_distance.data) / (batch_size**2 - batch_size)
        bandwidth /= self.kernel_mul ** (self.kernel_num // 2)
        return torch.exp(-L2_distance / bandwidth)

    def forward(self, source, target):
        batch_size = source.size(0)
        kernels = self.guassian_kernel(source, target)
        loss = 0
        for i in range(batch_size):
            s_kernel = kernels[:batch_size, i].mean()
            t_kernel = kernels[batch_size:, i].mean()
            loss += s_kernel + t_kernel - 2 * kernels[:batch_size, batch_size:].mean()
        return loss / batch_size

3.3 实时性要求

为满足故障定位的实时性（<100ms），我们做了以下优化：

1. 特征降维：使用PCA将128维特征压缩到32维，精度损失<2%
2. 模型量化：将FP32模型转为INT8，推理速度提升3倍
3. 缓存机制：预计算线路参数等不变特征

python复制from sklearn.decomposition import PCA

pca = PCA(n_components=32)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

# 量化模型
quantized_model = torch.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8
)

4. 实际应用效果与部署方案

4.1 性能指标

在IEEE 33节点测试系统上获得的实验结果：

4.2 部署架构

采用边缘计算架构部署系统：

code复制[智能终端] --RS485--> [边缘网关] --MQTT--> [云平台]
    ｜                      ｜
    ｜(波形采集)            ｜(特征提取+推理)
    ↓                      ↓
[合并单元]            [工控机运行PyTorch]

关键部署代码：

python复制# 边缘网关处理流程
def edge_processing(raw_data):
    # 1. 数据校验
    if not validate_checksum(raw_data):
        raise ValueError("Invalid checksum")
    
    # 2. 特征提取
    features = extract_features(raw_data)
    
    # 3. 模型推理
    with torch.no_grad():
        inputs = torch.FloatTensor(features).unsqueeze(0)
        params = torch.FloatTensor(get_physical_params())
        outputs = model(inputs, params)
        pred = outputs.argmax().item()
    
    # 4. 结果发布
    publish_mqtt({
        "timestamp": time.time(),
        "prediction": pred,
        "confidence": torch.softmax(outputs,1)[0,pred].item()
    })

4.3 维护与更新策略

1. 在线学习：每月用新数据微调模型，持续优化
2. A/B测试：新旧模型并行运行，对比效果
3. 异常检测：监控特征分布漂移，触发模型重训练

python复制# 在线学习示例
def online_learning(new_data, new_labels):
    optimizer = optim.SGD(model.parameters(), lr=0.0001)
    dataset = TensorDataset(new_data, new_labels)
    loader = DataLoader(dataset, batch_size=32)
    
    model.train()
    for epoch in range(5):  # 少量迭代
        for inputs, labels in loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

这个项目从理论分析到工程落地共耗时6个月，最大的体会是：电力系统的AI应用必须紧密结合物理约束，纯数据驱动的方法在安全关键场景中风险极高。我们通过将电路定律嵌入模型结构，既保证了精度又满足了可靠性要求。