摘要

近年来，在能源市场的发展要求以及相关政策的促进下，新能源越来越受到国内国际市场的重视。

2020年12月国务院颁布的《新时代的中国能源发展》白皮书中也明确提到我国未来在“碳达峰”、“碳中和”方面的要求。而风力发电作为新兴的清洁能源产业，对于改善能源结构、推动生态和环境建设以及实现能源的可持续利用具有十分重要的意义。

然而，由于风电机组运行环境等因素的影响，风机发电组故障常发降低了新能源发电的效率。

本项目基于MindSpore框架，对风力发电机组叶片的各项实时监测数据进行数据预处理，应用BP神经网络算法，对预处理完成的数据进行学习，并对已有风机叶片的状态进行判定，通过训练完成的神经网络模型对新采集的数据进行预测，并将可能发生裂痕风险的机组编号以及已经发生叶片裂痕的叶片数据进行预警，从而实现实时监控、无人监控、自动报警的功能，是针对过往依靠人力判定、依靠人力检测的创新，极大地降低了人力、财力投入，从而大大提高新能源发电的效率。

项目流程图

数据清洗

本项目从中国国电相关竞赛官方网站下载风机叶片的实时测试数据，打包成csv文件压缩包，作为本项目的数据基础。所获取的数据包含137,145个数据样本，为不同的风机叶片在不同时间段内实时采集的各参数的相关数据，其中任一样本包含450-500余条实时采集数据，所采集数据特征包含轮毂转速、轮毂角度、各叶片角度、超速传感器转速检测值、各变桨电机电流、5秒偏航对风平均值、x方向振动值、y方向振动值、液压制动压力、机舱气象站风速等共计75个相关参数，其数据大致结构如下表【】所示：

数据分析

始数据由于特征数量比较多，且每个特征的观测记录次数较多，故我们在对全部数据清洗之前对样例数据进行数据处理：

通过对样例的每个特征分布分析，我们发现大部分特征是没有很好的区分度的。此外，我们还将每一个特征进行频率分布的分析，其结果如上图所示：

通过上两图的分布情况，我们大致判定，该特征无法作为区分风机叶片是否有裂的显著特征，仍然需要对原始数据进行特征提取等方面的处理，在查阅了相关论文数据之后，【风机叶片检测的研究现状及进展_杨家欢】我们得知轮毂转速大于3等多种特征可以作为区分是否可能出现裂纹的重要特征。 此外，我们还对原始数据进行了异常值处理，以及归一化处理，其结果可视化如下两图所示：

主成分分析

主成分分析是设法将原来众多具有一定相关性（比如P个指标），重新组合成一组新的互相无关的综合指标来代替原来的指标。 主成分分析，是考察多个变量间相关性一种多元统计方法，研究如何通过少数几个主成分来揭示多个变量间的内部结构，即从原始变量中导出少数几个主成分，使它们尽可能多地保留原始变量的信息，且彼此间互不相关.通常数学上的处理就是将原来P个指标作线性组合，作为新的综合指标。 最经典的做法就是用F1（选取的第一个线性组合，即第一个综合指标）的方差来表达，即Var(F1)越大，表示F1包含的信息越多。因此在所有的线性组合中选取的F1应该是方差最大的，故称F1为第一主成分。如果第一主成分不足以代表原来P个指标的信息，再考虑选取F2即选第二个线性组合，为了有效地反映原来信息，F1已有的信息就不需要再出现在F2中，用数学语言表达就是要求Cov(F1, F2)=0，则称F2为第二主成分，依此类推可以构造出第三、第四，……，第P个主成分。 [4]  步骤 Fp = a1iZX1 + a2iZX2 + …… + api*ZXp 其中a1i, a2i, ……,api(i=1,……,m)为X的协方差阵Σ的特征值所对应的特征向量，ZX1, ZX2, ……, ZXp是原始变量经过标准化处理的值，因为在实际应用中，往往存在指标的量纲不同，所以在计算之前须先消除量纲的影响，而将原始数据标准化，本文所采用的数据就存在量纲影响[注：本文指的数据标准化是指Z标准化]。 A = (aij)p×m = (a1,a2,…am)，Rai = λiai，R为相关系数矩阵，λi、ai是相应的特征值和单位特征向量，λ1 ≥ λ2 ≥ …≥ λp ≥ 0 。 进行主成分分析主要步骤如下：

1. 指标数据标准化；
2. 指标之间的相关性判定；
3. 确定主成分个数m；
4. 主成分Fi表达式；
5. 主成分Fi命名。 通过对主成分分析的原理以及步骤的详细了解，本项目在MindSpore框架下对原始数据进行主成分分析，其代码如下所示：

import os
import csv
import numpy as np
import seaborn as sns
import mindspore as ms
import matplotlib.pyplot as plt
from mindspore import nn, context
from mindspore.ops import operations as ops
context.set_context(mode=context.PYNATIVE_MODE)#, device_target="Ascend")


def create_dataset(data_path):
    with open(data_path) as csv_file:
        data = list(csv.reader(csv_file, delimiter=','))

    label_map = {
        'Fault': 0,
        'Good': 1,
    }
    X = np.array([[float(x) for x in s[:-1]] for s in data[:150]], np.float32)
    Y = np.array([label_map[s[-1]] for s in data[:150]], np.int32)
    return X,Y


class Pca(nn.Cell):
    def __init__(self):
        super(Pca, self).__init__()
        self.reduce_mean = ops.ReduceMean(keep_dims=True)
        self.reshape = ops.Reshape()
        self.matmul_a = ops.MatMul(transpose_a=True)
        self.matmul_b = ops.MatMul(transpose_b=True)
        self.top_k = ops.TopK(sorted=True)
        self.gather = ops.GatherV2()

    def construct(self, x, dim=2):
        '''
        x:输入矩阵
        dim:降维之后的维度数
        '''
        X,Y = create_dataset(data_path)
        m = X.shape[0]
        # 计算张量的各个维度上的元素的平均值
        mean = self.reduce_mean(x, axis=1)
        # 去中心化
        x_new = x - self.reshape(mean, (-1, 1))
        # 无偏差的协方差矩阵
        cov = self.matmul_a(x_new, x_new) / (m - 1)
        # 计算特征分解
        cov = cov.asnumpy()
        e, v = np.linalg.eigh(cov)
        # 将特征值从大到小排序，选出前dim个的index
        e_index_sort = self.top_k(ms.Tensor(e), dim)[1]
        # 提取前排序后dim个特征向量
        v_new = self.gather(ms.Tensor(v), e_index_sort, 0)
        # 降维操作
        pca = self.matmul_b(x_new, v_new)
        return pca

def pca(X,Y):
    net = Pca()
    pca_data_tensor = ms.Tensor(np.reshape(X,(X.shape[0],-1)),ms.float32)
    pca_data = net(pca_data_tensor,dim=2)

    # plt
    color_mapping = {0: sns.xkcd_rgb['bright purple'],1: sns.xkcd_rgb['pale red'], 2: sns.xkcd_rgb['ochre']}
    colors = list(map(lambda x: color_mapping[x], Y))
    plt.scatter(pca_data[:, 0].asnumpy(), pca_data[:, 1].asnumpy(), c=colors)
    plt.show()

if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('D:\测试\test1.mindrecord', required=True, default=None, help='Location of data.')
    args, unknown = parser.parse_known_args()

    if args.data_url.startswith('s3'):
        data_path = 'D:\测试\test1.mindrecord'
        import moxing
        moxing.file.copy_parallel(src_url=os.path.join(args.data_url, 'D:\测试\test1.mindrecord'),
                                  dst_url=data_path)
    else:
        data_path = os.path.abspath(args.data_url)

    pca(*create_dataset(data_path))

基于MindSpore的模型构建

MindSpore旨在提供端边云全场景的AI框架。MindSpore可部署于端、边、云不同的硬件环境，满足不同环境的差异化需求，如支持端侧的轻量化部署，支持云侧丰富的训练功能如自动微分、混合精度、模型易用编程等。

如上图所示，在MindSpore上训练出来的模型文件，可通过Serving部署在云服务中执行，也可用过Lite执行在服务器、端侧等设备上。同时Lite支持通过独立工具convert进行模型的离线优化，实现推理时框架的轻量化以及模型执行高性能的目标。 MindSpore抽象各个硬件下的统一算子接口，因此，在不同硬件环境下，网络模型的编程代码可以保持一致。同时加载相同的模型文件，在MindSpore支持的各个不同硬件上均能有效执行推理。 推理方面考虑到大量用户使用C++/C编程方式，提供了C++的推理编程接口，相关编程接口在形态上与Python接口的风格较接近。 同时，通过提供第三方硬件的自定义离线优化注册，第三方硬件的自定义算子注册机制，实现快速对接新的硬件，同时对外的模型编程接口以及模型文件保持不变。

BP神经网络的原理与构建

BP神经网络可以分为两个部分，BP和神经网络。BP是 Back Propagation的简写，意思是反向传播。  BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。 其主要的特点是：信号是正向传播的，而误差是反向传播的。 举一个例子，某厂商生产一种产品，投放到市场之后得到了消费者的反馈，根据消费者的反馈，厂商对产品进一步升级，优化，一直循环往复，直到实现最终目的——生产出让消费者更满意的产品。产品投放就是“信号前向传播”，消费者的反馈就是“误差反向传播”。这就是BP神经网络的核心。

通过mindspore框架对BP神经网络进行构建，其主要实现代码如下所示：

##BP网络的定义：
class ini_BP_net(nn.Cell):
    def __init__(self, n_feature, n_hidden, n_output):
        super(ini_BP_net, self).__init__()
        # 构造隐含层和输出层
        self.hidden = nn.Dense(n_feature, n_hidden)
        self.output = nn.Dense(n_hidden, n_output)
        #self.tanh = ms.ops.Tanh()
        self.relu = ms.ops.ReLU()
        #self.softmax = ms.ops.Softmax()
        self.sigmoid = ms.ops.Sigmoid()

    def construct(self, x):
        # 前向计算
        hid = self.relu(self.hidden(x))
        out = self.sigmoid(self.output(hid))
        return out

损失函数的自定义

损失函数（loss function）就是用来度量模型的预测值f(x)与真实值Y的差异程度的运算函数，它是一个非负实值函数，通常使用L(Y, f(x))来表示，损失函数越小，模型的鲁棒性就越好。 损失函数使用主要是在模型的训练阶段，每个批次的训练数据送入模型后，通过前向传播输出预测值，然后损失函数会计算出预测值和真实值之间的差异值，也就是损失值。得到损失值之后，模型通过反向传播去更新各个参数，来降低真实值与预测值之间的损失，使得模型生成的预测值往真实值方向靠拢，从而达到学习的目的。 代码实现如下：

def step_end(self, run_context):
    """After step end print training info."""
    callback_params = run_context.original_args()
    step_mseconds = (time.time() - self.step_time) * 1000
    loss = callback_params.net_outputs
    if isinstance(loss, (tuple, list)):
        if isinstance(loss[0], ms.Tensor) and isinstance(loss[0].asnumpy(), np.ndarry):
            loss = loss[0]
    if isinstance(loss, ms.Tensor) and isinstance(loss.asnumpy(), np.ndarray):
        loss = np.mean(loss.asnumpy())
    self.losses.append(loss)
    cur_step_in_epoch = (callback_params.cur_step_num - 1) % callback_params.batch_num + 1

    # Boundary check.
    if isinstance(loss, float) and (np.isnan(loss) or np.isinf(loss)):
        raise ValueError(f"Invalid loss, terminate training.")

优化器的自定义

神经网络的参数巨多，需要合适的算法来进行参数的学习，也就是优化器。可以说，优化器是神经网络的眼睛，是神经网络蓬勃发展的基础。所有要训练的参数记为 θ ,目标函数为 J(θ) ,考虑最小化目标函数，要用梯度下降法。梯度为 △θJ(θ) 。梯度是函数变化最快的方向，如果函数是凸函数，那么梯度相反的方向就是目标函数更小的方向，梯度下降就是在这个方向上快速的向最小点移动。通常都会有一个步长 η 来控制下降的快慢。 神经网络中的目标函数并不是凸函数，所以梯度下降很有可能就困在局部最小或者鞍点，因为此时，梯度很小，无法更新。好的优化器是会考虑这些，想办法从鞍点跳出的。 MindSpore所有优化逻辑都封装在Optimizer对象中，在这里，我们使用Momentum优化器。mindspore.nn也提供了许多其他常用的优化器函数，如Adam、SGD、RMSProp等。

我们需要构建一个Optimizer对象，这个对象能够基于计算得到的梯度对参数进行更新。为了构建一个Optimizer，需要给它一个包含可优化的参数，如网络中所有可以训练的parameter，即设置优化器的入参为net.trainable_params()。 然后，设置Optimizer的参数选项，比如学习率、权重衰减等。代码如下：

optimizer = nn.Adam(params=bp_net.trainable_params(), learning_rate=learn_data, use_amsgrad=True)

回调机制的自定义

回调（call back，一个动词词组）机制，是一门编程语言，使得下层模块/库可以调用或执行上层模块定义的代码的机制。上层模块所定义的、被（下层模块）调用或动态绑定的代码，则被称为回调函数 (简称回调、callback，一个名词)。框架是骨架式方案，需要上层模块(为该骨架式方案)提供代码支持。 代码实现如下：

#自定义回调函数，获取‘mae’
class train_val_monitor(ValAccMonitor):
    def __init__(self,
                 model,
                 dataset_val,
                 num_epochs,
                 interval=1,
                 eval_start_epoch=1,
                 save_best_ckpt=True,
                 ckpt_directory="./",
                 best_ckpt_name="best.ckpt",
                 metric_name="mae",
                 dataset_sink_mode=True):
        super(ValAccMonitor, self).__init__()
        self.model = model
        self.dataset_val = dataset_val
        self.num_epochs = num_epochs
        self.eval_start_epoch = eval_start_epoch
        self.save_best_ckpt = save_best_ckpt
        self.metric_name = metric_name
        self.interval = validator.check_int(interval, 1, Rel.GE, "interval")
        self.best_res = 0
        self.dataset_sink_mode = dataset_sink_mode

        if not os.path.isdir(ckpt_directory):
            os.makedirs(ckpt_directory)
        self.best_ckpt_path = os.path.join(ckpt_directory, best_ckpt_name)

模型训练

们通过以下四步进行模型训练，构建数据集、定义BP神经网络、定义超参、损失函数及优化器和输入训练轮次和数据集进行训练。 代码实现如下：

if __name__ == "__main__":
    n_feature = 75
    n_hidden = 32
    n_output = 1
    learn_data = 0.001
    epochs = 100
    ms.set_context(device_target="CPU")
    dataset = create_train_dataset()
    # 构建模型
    bp_net = ini_BP_net(n_feature, n_hidden, n_output)
    # 测试
    loss_fc = ms.nn.MSELoss(reduction="sum")
    loss_scale_manager = ms.FixedLossScaleManager()
    optimizer = nn.Adam(params=bp_net.trainable_params(), learning_rate=learn_data, use_amsgrad=True)
    model = ms.Model(bp_net, loss_fn=loss_fc, optimizer=optimizer, metrics={'mae'}, loss_scale_manager=None)
    #model.train(epochs, train_dataset=dataset, callbacks=[train_val_monitor(model, 
    # dataset_val, num_epochs=epochs), MyMonitor(learn_data, 4096)], dataset_sink_mode=True)
    model.train(epochs, train_dataset=dataset, callbacks=[MyMonitor(learn_data, 10425)], 
                dataset_sink_mode=True) #63652

    # 直接保存网络模型
    ms.save_checkpoint(bp_net, "./BPNet_checkpoint.ckpt")

    # 模型预测
    list_data = np.arange(1, 76)
    list_label = np.arange(76, 77)

实验结果

在正式的实验中，我们首先采用了预实验的方法来寻找训练函数中各个参数的合理设置范围。

根据本项目的数据集（包含训练集及测试集），我们的参数设置如下表：

根据上述参数设置，我们进行了-预实验：其训练过程如下图所示：

如上述训练过程，从训练损失值loss来看，前25次迭代，loss迅速从1.2下降到0.4，而25次迭代之后，loss值变化不大而且抖动较大，表明训练效果不好。

经过不断地参数调整设置，我们将BP模型的相关参数设置如下表所示：

在相应的参数设置下，由于在学习模式有自定义训练和Model高阶API训练，我们分别对两种模式进行了训练，其训练过程如下两图所示：

通过上述两种训练模式的对比，我们得知：自定义模型训练和高阶API模型训练的模式下，两者的loss值变化趋势是相似的，均从0.66开始平缓的下降，不同之处在于训练过程中，自定义训练模式下，loss值的变化自始至终都是平缓的下降，变化过程中没有抖动，而高阶API训练模式下，loss值会出现短暂的抖动现象，虽然整体是下降的，但是对最终的训练模型预测精度会造成一定的影响。

为了显示模型建立的完整性，我们将形同的BP模型迁移至另外一个框架PyTorch中，进行训练对比，同样，参数的设置与在MindSpore之中的模型参数设置保持一致，与上表相同，其表现结果如下四图所示：

通过上述各实验曲线图，我们将各个不同条件下的表现进行对比，得到下表：

特色创新

MindSpore 最大的特点就是开发门槛大大降低，提高开发效率，这样可以显著减少模型开发时间。因此，使用MindSpore的优势可以总结为以下四点：

1. 简单的开发体验；
2. 灵活的调试模式；
3. 充分发挥硬件潜能；
4. 全场景快速部署。

在当前的风电场生产背景下，以风电场的运行状态监测数据为切入点，结合MindSpore，通过数据分析、BP神经网络等方法，设计并实现了风力发电场设备运行的预警，对风电设备的测点进行实时监测，同时利用历史数据进行预测，达到预警的目的，降低运维成本，同时提高风电场的生产效益，实现良性循环。

本项目在研究中，虽然采用了最为经典的神经网络模型之一，BP神经网络，但是在研究的过程中并不是简单的通过引用框架中已经定义好的模型进行简单的测试验证工作，而是创新性的基于MindSpore框架，从BP神经网络模型的基本原理以及相关步骤进行自定义网络模型，包括前馈机制、损失函数等的自定义，充分利用MindSpore进行开发，让旧模型在新框架、新平台焕发出新的生机。

此外，由于本项目中所采用的MindSpore框架是一个端、边、云平台相互协同的框架，在此优势之上，本项目的模型可以更加容易的迁移到不同的使用场景之中，从而实现模型效益的最大化，真正为新能源发展、为工业互联网的发展助力。

总结

风能凭借其储量丰富、可再生等优势，成为了发展速度最快的新能源之一。 通过对风机发展现状的学习，发现风电机组故障预警技术目前还存在缺陷，且风 电场所配备的SCADA系统不能充分地反映机组的性能，不能及时发现机组的故 障，造成较大的经济损失。为解决上述问题，并充分利用SCADA系统及时获取 风电机组的健康状态，用MindSpore深度学习框架对风电机组的故障预警及状态监测进行深入研究。

通过上述的实验研究我们发现，BP神经网络无论在网络理论还是在性能方面已比较成熟。其突出优点就是具有很强的非线性映射能力和柔性的网络结构。网络的中间层数、各层的神经元个数可根据具体情况任意设定，并且随着结构的差异其性能也有所不同。但是BP神经网络也存在以下的一些主要缺陷：

1. 学习速度慢，即使是一个简单的问题，一般也需要几百次甚至上千次的学习才能收敛。
2. 容易陷入局部极小值。
3. 网络层数、神经元个数的选择没有相应的理论指导。
4. 网络推广能力有限。

因此，即便是在MindSpore的框架下，如此成熟的神经网络模型在面对大数据量的任务的时候在学习时间、预测精度等方面的表现也没有呈现出最优的状态。

展望

由于时间和能力有限，研究还存在不足，未来主要研究方向如下：

1. MindSpore深度学习框架近几年发展十分迅速，以早期算法为基础产生了许多高效的新算法。本研究中仅采用BP神经网络建立风电机组性能预测模型，侧重于工程应用，对框架算法的研究深度还不够，有待进一步研究。
2. 本文研究在故障发生早期，利用SCADA系统运行数据和建立的风机性能预测模型对机组功率、转速等异常状态进行预警。由于风机的故障类型和种类都较多，在当前研究的基础上，应进一步深入研究故障准确定位和诊断问题。
3. 经过查阅相关的文献以及开源资料，我们了解到，BP神经网络在诸如PyTorch等其他框架下，已经有了不少的开发成果，后期的研究中会使用不同框架，同样的数据集以及同样的模型进行横向开发对比，从而突出不同框架的特点对比；
4. 在本项目研究中发现的，BP神经网络本身的缺陷，极易陷入局部最优解，经过大量的文献资料查阅，我们发现可以使用各类优化算法解决这个问题，后续的研究中，我们将使用粒子群优化算法PSO、蚁群优化算法等对已经在MindSpore上开发的BP神经网络进行优化处理。
5. 此外，本模型的应用不仅是局限于使用在风机叶片的裂纹预测上，通过使用不同的数据类型以及适当的迁移，配合相应的参数设置，本项目实现的模型还可以应用在工业的各方面故障预警当中，比如：路基空洞预测警示、食药品仪器状态检测及警示等方面，能够实现真正助力工业互联网的构建。