基于神经网络的变压器故障分类诊断

狗狗学不会

已于 2024-01-08 00:46:16 修改

阅读量1k

点赞数 14

文章标签：神经网络人工智能

于 2024-01-08 00:44:53 首次发布

本文链接：https://blog.csdn.net/qq_54575112/article/details/135447357

版权

一.绪论

变压器是电力系统中分布广泛、造价昂贵、结构复杂的电气设备，其在电能传送和电压转换方面承担着至关重要的任务。它的正常运行直接关系到整个电力系统的安全性和稳定性。对于油浸式变压器而言，随着运行的持续，变压器油与其中的固体有机材料会逐渐发生老化和分解。由于不同类型的故障会导致油中产生不同类型的气体，通过对油中气体的分析，我们可以有效地判断变压器的故障类型。

油浸式变压器的运行过程中，油与固体有机材料的老化和分解是一个自然而不可避免的过程。由于不同类型的故障引起的油中气体产生量和比例各异，因此通过对油中气体的详细分析，我们能够准确地识别变压器可能存在的问题。这种方法为我们提供了一种可靠的手段，以便及时发现并解决潜在的故障，确保变压器的可靠运行。

值得注意的是，油中气体分析技术的应用不仅仅在于检测故障，更重要的是在于预防性维护。通过定期对变压器油中气体进行监测和分析，我们能够及时发现变压器内部可能存在的问题，采取预防措施，延长变压器的使用寿命，提高电力系统的可靠性。

油浸式变压器的正常运行对电力系统至关重要。通过对变压器油中气体的分析，我们可以在故障发生前及时识别问题，实现预防性维护，确保电力系统的安全性和稳定性。这种先进的监测技术为电力设备的管理和维护提供了有力支持，为电力系统的可靠运行保驾。

本文将使用神经网络来对变压器故障来进行分类诊断。

二.实验数据

三.模型架构可视化

自己搭建模型以及可视化

四.代码

class model(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(model, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size,hidden_size),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_size,hidden_size),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_size,hidden_size),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_size, num_classes),
            nn.Softmax(dim=1)
        )
    def forward(self, x):

        x = self.model(x)
        return x

#train
from torch.utils.data import DataLoader
from data.dataset import dataset,data_split
from model import model
import torch.optim as optim
import torch
import wandb
import os

# Initialize wandb
os.environ["WANDB_API_KEY"] = ''
os.environ["WANDB_MODE"] = "offline"

wandb.init(project='model', name='best2')



if __name__ == "__main__":
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

    result_data = dataset('data/a.csv',if_normalize=True)
    data_train, data_test = data_split(result_data, 0.8)
    train_data = DataLoader(data_train, batch_size=512, shuffle=True)
    test_data = DataLoader(data_test, batch_size=1, shuffle=True)

    epochs = 15000
    input_size = 5
    hidden_size = 256
    output_size = 7
    lr = 0.001

    model = model(input_size, hidden_size, output_size).to(device)
    optim = optim.Adam(model.parameters(), lr=lr)
    loss_func = torch.nn.CrossEntropyLoss()

    for epoch in range(epochs):
        train_loss = 0
        train_corrects = 0
        num_batches = len(train_data)

        for i, (inputs, labels) in enumerate(train_data):
            model.train()
            inputs = inputs.to(device)
            labels = labels.to(device)

            out = model(inputs)
            loss = loss_func(out, labels)
            train_loss += loss.item()

            # 计算train的准确率
            prediction = torch.max(out, 1)[1]
            train_corrects += torch.sum(prediction == labels).item()

            optim.zero_grad()
            loss.backward()
            optim.step()

        avg_train_loss = train_loss / num_batches
        train_acc = train_corrects / len(data_train)

        if epoch % 10 == 0:
            model.eval()
            with torch.no_grad():
                test_loss = 0
                total = len(data_test)
                test_corrects = 0

                for i, (data, labels) in enumerate(test_data):
                    data = data.to(device)
                    labels = labels.to(device)

                    outputs = model(data)
                    loss = loss_func(outputs, labels)
                    test_loss += loss.item()

                    prediction = torch.max(outputs, 1)[1]
                    test_corrects += torch.sum(prediction == labels).item()

                avg_test_loss = test_loss / len(test_data)
                test_acc = test_corrects / total
                print(
                    f"Epoch {epoch + 1}, Training Loss: {avg_train_loss}, Train Acc: {train_acc}, Test Loss: {avg_test_loss}, Test Acc: {test_acc}")
                #保存模型
                torch.save(model.state_dict(), 'save/model.pt')
                # Log to wandb
                wandb.log({"Train Loss": avg_train_loss, "Train Acc": train_acc,
                           "Test Loss": avg_test_loss, "Test Acc": test_acc})
    wandb.finish()