CN107579846A

CN107579846A - 一种云计算故障数据检测方法及系统

Info

Publication number: CN107579846A
Application number: CN201710729189.1A
Authority: CN
Inventors: 姜瑛; 刘诚诚; 李凌宇; 刘英莉; 丁家满; 汪海涛
Original assignee: Kunming University of Science and Technology
Current assignee: Kunming University of Science and Technology
Priority date: 2017-08-23
Filing date: 2017-08-23
Publication date: 2018-01-12
Anticipated expiration: 2037-08-23
Also published as: CN107579846B

Abstract

本发明涉及一种云计算故障数据检测方法及系统，属于云故障检测领域。本发明包括：云计算故障训练数据处理步骤，对云计算故障训练数据集中的数据进行处理，得到每条故障训练数据的隶属度、每个故障类别的故障特征权重；待检测云计算数据所属故障类别判断步骤，根据故障训练数据的处理结果并结合云计算故障训练数据集扩充规则判断待检测云计算数据所属类别；云计算故障训练数据集扩充步骤，将满足云计算故障训练数据集扩充规则的待检测云计算数据及其类别信息加入故障训练数据扩充集。本发明有助于完善故障训练数据模型，识别新的故障。

Description

一种云计算故障数据检测方法及系统

技术领域

本发明涉及一种云计算故障数据检测方法及系统，属于云故障检测领域。

背景技术

故障检测主要研究如何对系统中出现的故障进行检测、分离和识别，即判断故障是否发生，定位故障发生的位置和种类，以确定故障的大小和发生的时间等。近年来，云计算的应用技术越来越广泛，然而大量的恶意攻击和其自身的复杂性与大规模性使得系统及其上的各种软硬件经常发生故障，引起部分甚至所有服务的失效。云计算故障检测技术已经成为该领域的研究热点。饶翔等提出一种基于故障注入测试的故障特征提取方法，首先过滤噪声日志；然后构造故障识别器识别不同故障的早期特征；最后为每类故障构造限状态追踪器追踪该故障的后期传播状态，从而在故障被识别出来后持续跟踪故障传播状态。张丹伟等提出一种基于模拟退火算法的隐马尔科夫模型用于故障数据检测，首先利用模拟退火算法全局寻优的特性求解隐马尔科夫模型的初始参数，解决传统隐马尔科夫模型对初始参数敏感的问题；然后用改进的隐马尔科夫模型对故障数据进行检测，使结果达到全局最优，提高了检测精度。SongFu等提出了一种云环境下基于贝叶斯与决策树的主动故障管理方法，首先利用贝叶斯模型预测出故障点，系统管理员对其进行标记，然后利用标记的数据点构建决策树，最后对未标记的数据点进行故障预测，但决策树存在过学习问题，对预测结果有较大的影响。Chirag N.Modil等人将贝叶斯和基于Snort的检测系统用于云平台的故障检测，首先利用Snort采集云环境的网络数据，然后利用贝叶斯进行分类，实验结果表明，此系统降低了误检率。

目前，针对云计算故障数据检测的方法，主要是通过数据的采集，建立故障训练数据训练模型，然后对待检测云计算数据进行检测，并没有充分考虑训练数据的内在联系，且故障类型库的更新不够及时，将影响新故障的有效识别。

发明内容

针对上述问题，本发明提供了一种云计算故障数据检测方法及系统，有助于判断云计算平台发生哪些故障，为故障恢复提供支持。

本发明的技术方案是：一种云计算故障数据检测方法，包括：

云计算故障训练数据处理步骤，对云计算故障训练数据集中的数据进行处理，得到每条故障训练数据的隶属度、每个故障类别的故障特征权重；

待检测云计算数据所属故障类别判断步骤，根据故障训练数据的处理结果并结合云计算故障训练数据集扩充规则判断待检测云计算数据所属类别；

云计算故障训练数据集扩充步骤，将满足云计算故障训练数据集扩充规则的待检测云计算数据及其类别信息加入故障训练数据扩充集。

所述方法的具体步骤如下：

Step1：云计算故障训练数据处理；

Step1.1：输入含m个故障类别且每个故障类别含有n个故障训练数据的云计算故障训练数据集D＝{D₁,…,D_i,…,D_m}，D_i＝{x_i1,…,x_ij,…,x_in}，x_ij＝[x_ij1,…,x_ijl,…,x_ijp,c_i]， i＝1,2,…,m，j＝1,2,…,n，l＝1,2,…p，其中D_i表示属于第i个故障类别的故障训练数据， x_ij表示D_i中第j条故障训练数据，x_ijl表示D_i中第j条故障训练数据的第l个故障特征，c_i表示x_ij所属故障类别，m表示故障类别数，n表示D_i中故障训练数据个数，p 表示故障训练数据的故障特征数；

Step1.2：利用基于密度聚类的思想将D中每个故障类别的故障训练数据分别构建成一个最小球，计算最小球的球中心a_i和半径R_i，并结合故障训练数据在最小球中的位置，按照不同规则确定故障训练数据的隶属度ms_ij，其中a_i表示D中第i个故障类别的故障训练数据构建最小球的球中心，R_i表示D中第i个故障类别的故障训练数据构建最小球的半径，ms_ij表示D_i中第j条故障训练数据的隶属度；

Step1.3：根据云计算故障训练数据故障特征的模糊熵值来计算每个故障类别的特征权重w_i，w_i＝{w_i1,…,w_il,…,w_ip}，并将w_i存入w，w＝{w₁,…,w_i,…,w_m},其中w表示 D中故障训练数据的故障特征权重集合，w_i表示D_i中故障训练数据的故障特征权重， w_il表示第i个故障类别第l个故障特征的权重；

Step2：待检测云计算数据所属故障类别判断；其中待检测云计算数据集用U表示，U＝{u₁,…,u_q,…,u_e}，uq＝{u_q1,…,u_ql,…,u_qp}，其中u_q表示待检测云计算数据集U 中第q个云计算数据，u_ql表示U中第q个云计算数据中第l个故障特征，q＝1,2,…,e， e表示待检测云计算数据个数；

Step2.1：判断q是否小于等于e：如果是，提取u_q，并根据公式计算u_q与D中故障训练数据的加权欧式距离d(x_ij)，并根据距离点排序，构建一个集合distanceSet；否则，执行Step3；

Step2.2：提取distanceSet中k个最小距离对应的故障训练数据，并设置阈值σ₁，σ₂，其中k小于等于n×m；

Step2.3：根据k个故障训练数据中隶属度最大值Max_ms对应故障训练数据的类别信息和云计算故障训练数据集扩充规则来确定待检测云计算数据的类别；其中云计算故障训练数据集扩充规则为：①根据Max_ms大于阈值σ₁且待检测云计算数据与Max_ms对应故障训练数据所属故障类别的理想故障训练数据的距离小于匹配阈值ρ来确定将该待检测云计算数据及其类别信息加入已知故障类别扩充集 known_fault；②根据Max_ms小于阈值σ₂来确定待检测云计算数据为未知故障类别并将该数据和其类别信息加入未知故障类别扩充集Unknown_fault；q++，执行 Step2.1；

Step3：云计算故障训练数据集扩充，将满足云计算故障训练集扩充规则的known_fault_set和Unknown_fault_set存入云计算故障训练数据扩充集Ext_D，其中 Ext_D用于扩充云计算故障训练数据集D。

所述故障训练数据的隶属度，计算方法为：

1)初始化：i＝1，球中心集Centroids为空，最小球半径集Radious为空，隶属度集ms为空；

2)判断i是否小于等于m：如果是，提取D_i中的故障训练数据，令j＝1，并执行3)；否则，输出Centroids、Radious和ms，并执行Step1.3；

3)判断j是否小于等于n：如果是，执行4)；否则，令j＝1，并执行6)；

4)根据公式(1)计算x_ij与D_i中其他故障训练数据之间的欧式距离distance(x_ij,x_ir)，将distance(x_ij,x_ir)存入d_j，并对d_j升序排列，d_j表示D_i中第j个故障训练数据与D_i中其他数据距离的集合；

其中x_irl表示D_i中第r个故障训练数据的第l个故障特征，r≠j且r＝1,2,…,n，n为D_i中的故障训练数据个数；

5)提取距离集d_j中前K个值(K≤n-1)，计算K个值的倒数和z_ij及z＝z+z_ij，并将z_ij存入z_i，其中z表示z_ij的累加，z_i表示D_i中故障训练数据距离集前K个值倒数和集；j++，执行3)；

6)判断j是否小于等于n：如果是，执行7)；否则，对G_i降序排列，G_i为D_i中故障训练数据的密度集，并执行8)；

7)根据公式(2)计算D_i中x_ij的密度density(x_ij)，并将density(x_ij)存入G_i；j++，执行6)；

8)提取G_i中最大密度所对应的故障训练数据x_max，计算x_max与D_i中其他故障训练数据的欧式距离，获得最小距离对应的故障训练数据x_min；

9)根据公式(3)计算得到球中心a_i，并将球中心a_i存入球中心集Centroids；

a_i＝0.6*x_max+0.4*x_min(3)

10)计算a_i与D_i中故障训练数据的欧式距离，并求距离平均值aver(D_i)，设置最小球半径调节系数coefR，根据公式(4)计算最小球半径R_i，将R_i存入Radious；令 j＝1，并执行11)；

其中，n表示D_i中故障训练数据的个数，并将R_i存入最小球半径集Radious中；

11)判断j是否小于等于n：如果是，执行12)；否则，将ms_i存入ms， ms_i＝{ms_i1,…,ms_ij,…,ms_in}，其中ms_i表示D_i中故障训练数据的隶属度集合，i++，并执行2)；

12)根据公式(5)计算x_ij与球中心a_i的欧式距离distance(a_i,x_ij)；

其中a_il为故障类别i的球中心的第l个故障特征；

13)判断distance(a_i,x_ij)是否小于R_i：如果是，执行14)；否则，执行15)；

14)根据公式(6)计算x_ij的隶属度ms_ij，并存入ms_i；j++，并执行11)；

15)根据公式(7)计算x_ij的隶属度ms_ij，并存入ms_i；j++，并执行11)；

所述故障特征的权重，计算方法为：

1)初始化：i＝1，故障特征权重集w为空，理想故障训练数据集id为空；

2)判断i是否小于等于m：如果是，执行3)；否则，输出w和id， id＝{id₁,…,id_i,…,id_m}，其中id为D中每个故障类别的理想故障训练数据的集合，并执行Step2；

3)提取D_i中的故障训练数据，根据公式(8)计算第i个故障类别的理想故障训练数据id_i，id_i＝{id_i1,…,id_il,…,id_ip}，并将id_i存入id；其中id_i表示D_i中故障训练数据的理想故障训练数据，id_il表示D_i中故障训练数据的理想故障训练数据的第l个故障特征；令j＝1，并执行4)；

4)判断j是否小于等于n：如果是，获取D_i中的第j个云计算故障训练数据x_ij，令l＝1，并执行5)；否则，令l＝1，并执行7)；

5)判断l是否小于等于p：如果是，执行6)；否则，将s_ij存入s_i，s_ij＝{sim_l(i,j),…,sim_l(i,j),…,sim_p(i,j)}，其中s_i表示D_i中每个故障训练数据的故障特征与id_i对应的故障特征的相似度集，j++，执行4)；

6)根据公式(9)计算x_ij第l个故障特征与理想故障训练数据id_i第l个故障特征的相似度sim_l(i,j)，并将其存入s_ij，其中s_ij表示D_i中第j个故障训练数据的故障特征与 id_i中对应故障特征的相似度集合；l++，执行5)；

7)判断l是否小于等于p：如果是，执行8)；否则，令l＝1，并执行9)；

8)根据s_i和公式(10)计算D_i中故障训练数据第l个故障特征的模糊熵值H(l)和H_sum＝H_sum+1/H(l)，其中H_sum表示故障特征模糊熵值倒数的累加；l++，执行7)；

9)判断l是否小于等于p：如果是，执行10)；否则，将w_i存入w， w_i＝{w_i1,…,w_il,…,w_ip}，i++，执行2)；

10)根据公式(11)计算D_i中故障训练数据第l个故障特征的权重w_il，并将w_il存入w_i；l++，执行9)；

所述判断待检测云计算数据的类别的方法：

1)初始化：v＝1，Max_ms＝0；

2)判断v是否小于等于k：如果是，提取第v个近邻故障训练数据的隶属度ms_v；否则，执行4)；

3)判断ms_v是否大于等于Max_ms：如果是，将ms_v的值赋给Max_ms，并获取该故障训练数据的类别信息；否则，v++，并执行2)；

4)判断Max_ms是否大于σ₁：如果是，提取Max_ms对应故障训练数据所属故障类别的最小球半径R_s，设置匹配阈值ρ＝2R_s，执行5)；否则，执行7)；

5)根据公式(12)计算u_q与Max_ms对应故障训练数据所属故障类别的理想故障训练数据id_{Max_ms}的相似度dsim；

其中，id_{Max_msl}表示Max_ms对应故障训练数据所属故障类别的理想故障训练数据id_{Max_ms}的第l个故障特征；

6)判断dsim是否小于等于ρ：如果是，将u_q所属的故障类别判断为Max_ms 对应故障训练数据的类别，并将u_q及其类别信息加入已知故障类别扩充集 known_fault_set，并执行9)；否则，执行8)；

7)判断Max_ms是否小于σ₂：如果是，将u_q所属的故障类别判断未知故障类别，并将u_q及其类别信息加入未知故障类别扩充集Unknown_fault_set，并执行9)；否则，执行8)；

8)将u_q所属的故障类别判断为Max_ms对应故障训练数据的类别；

9)输出u_q的类别信息。

所述σ₁＝0.94，σ₂＝0.4，k＝2。

所述K＝3。

一种云计算故障数据检测系统，包括：

云计算故障训练数据处理装置，用于对云计算故障训练数据集中的数据进行处理，得到每条故障训练数据的隶属度、每个故障类别的故障特征权重；

待检测云计算数据所属故障类别判断装置，用于根据故障训练数据的处理结果并结合云计算故障训练数据集扩充规则判断待检测云计算数据所属类别；

云计算故障训练数据集扩充装置，用于将满足云计算故障训练数据集扩充规则的待检测云计算数据及其类别信息加入故障训练数据扩充集。

本发明的有益效果是：

(1)本发明定义了基于密度聚类思想的隶属度，充分考虑类中故障训练数据与故障训练数据之间的关系，有助于减小云计算故障训练数据集中野值或噪声数据对分类的影响；

(2)本发明通过计算故障训练数据特征的权重，有助于区别故障特征的重要程度；

(3)本发明定义了云计算故障训练数据集扩充规则，有助于完善故障训练数据模型，识别新的故障；

(4)通过检测云计算故障数据，有助于判断云平台发生哪些故障及故障发生的位置并为故障恢复做准备。

附图说明

图1是本发明的流程图；

图2为图1中步骤S1中S1.2的具体流程；

图3为图1中步骤S1中S1.3的具体流程；

图4为图1中步骤S2中S2.3的具体流程。

具体实施方式

下面结合附图和实施例，对本发明作进一步说明，但本发明的内容并不限于所述范围。

实施例1：如图1-4所示，一种云计算故障数据检测方法，包括：

一种云计算故障数据检测系统，包括：

实施例2：如图1-4所示，云计算故障训练数据集D如表1所示，

表1

云计算数据集U如表2所示，

表2

本实例使用云计算故障数据作为故障训练数据集D。该D是有2个故障类别10 个故障训练数据且每个数据有4个故障特征组成，其中类别1为云计算网络故障、类别2为云计算IO端口故障，4个故障特征分别为cpu使用率、硬盘使用率，IO端口使用率以及网络使用量；D＝{D₁,…D_i,…,D_m}，D_i＝{x_i1,…,x_ij,…,x_in}， xij＝[x_ij1,…,x_ijl,…,x_ijp,c_i]，i＝1,.2,…,m，j＝1,2,…,n，l＝1,2,…,p，其中D_i为故障类别i 的故障训练数据，x_ij为故障类别i中第j条故障训练数据，x_ijl为故障类别i中第j条故障训练数据的第l个故障特征，m为故障类别数，n为对应故障类别中故障训练数据数，p为故障训练数据的特征数，c_i为故障训练数据的类别。

本实例中待检测云计算数据集U由4条数据组成,U＝{u₁,…,u_q,…,u_e}， u_e＝[u_q1,…,u_ql,…,u_qp]，其中u_q表示U中第q条待检测云计算数据，u_ql表示U中第q 条待检测云计算数据的第l个故障特征，q表示待检测云计算数据的个数，p表示待检测云计算数据的故障特征数。

该方法检测待检测云计算数据集中的故障数据，对故障数据进行分类并将满足故障训练数据集扩充规则的故障数据加入故障训练数据集。

云计算故障检测方法的具体步骤如下：

Step1：云计算故障训练数据处理；

Step1.1：输入含m个类的云计算故障训练数据集D：

本实例中，输入2个故障类别的云计算故障训练数据集D，且每类故障有5个故障训练数据，每个故障训练数据共4个故障特征。其中D＝{D₁,D₂}，

D₁＝{x₁₁,x₁₂,x₁₃,x₁₄,x₁₅}，

x₁₁＝[x₁₁₁,x₁₁₂,x₁₁₃,x₁₁₄,c₁]＝

[0.012515664,0.18907768,0.0061000003,7.6761626E-7,1]，

x₁₂＝[x₁₂₁,x₁₂₂,x₁₂₃,x₁₂₄,c₁]＝

[0.011292338,0.18902111,0.0061000003,7.6723273E-7,1]，

x₁₃＝[x₁₃₁,x₁₃₂,x₁₃₃,x₁₃₄,c₁]＝[0.010025084,0.18909907,0.0061000003,2.558721E-7,1]，

x₁₄＝[x₁₄₁,x₁₄₂,x₁₄₃,x₁₄₄,c₁]＝[0.021276593,0.18881398,0.0061000003,2.558721E-7,1]，

x₁₅＝[x₁₅₁,x₁₅₂,x₁₅₃,x₁₅₄,c₁]＝[0.036204755,0.18909341,0.006100003,7.6723273E-7,1]，

D₂＝{x₂₁,x₂₂,x₂₃,x₂₄,x₂₅}，

x₂₁＝[x₂₁₁,x₂₁₂,x₂₁₃,x₂₁₄,c₂]＝[0.11500001,0.2757709,0.6922,5.12E-7,2]，

x₂₂＝[x₂₂₁,x₂₂₂,x₂₂₃,x₂₂₄,c₂]＝[0.115143955,0.27486098,0.6906,7.6761626E-7,2]，

x₂₃＝[x₂₃₁,x₂₃₂,x₂₃₃,x₂₃₄,c₂]＝[0.11779451,0.2758971,0.6932,8.995503E-7,2]，

x₂₄＝[x₂₄₁,x₂₄₂,x₂₄₃,x₂₄₄,c₂]＝[0.12094766,0.27608985,0.6944,2.558721E-7,2]，

x₂₅＝[x₂₅₁,x₂₅₂,x₂₅₃,x₂₅₄,c₂]＝[0.016250014,0.2723512,0.701,2.5574423E-7,2]。

Step1.2：利用基于密度聚类的思想将D中每个故障类别分别构建成一个最小球，计算每个故障类别的球中心a_i和最小球半径R_i，并结合故障训练数据在最小球中的位置，按照不同规则确定故障训练数据的隶属度ms_ij；

具体方法：

1)初始化：i＝1，centroids为空，Radious为空，ms为空；

2)判断i是否小于等于m：1<2，提取D₁中的故障训练数据，令j＝1；

3)判断j是否小于等于n：1<5，执行4)，否则，执行6)；

4)根据欧氏距离公式计算x₁₁与D₁中其他故障训练数据之间的欧式距离distance(x₁₁,x_1r)，r＝2,3,4,5，将distance(x₁₁,x_1r)存入距离集d₁，d₁＝{distance(x₁₁,x₁₂),distance(x₁₁,x₁₃),distance(x₁₁,x₁₄),distance(x₁₁,x₁₅)}＝{0.0012246332,0.0024906719,0.0087648967,0.0236890962}；并对d₁升序排列， d₁＝{0.0012246332,0.0024906719,0.0087648967,0.0236890962}；

5)提取d₁中前3个值{0.0012246332,0.0024906719,0.0087648967}，计算其倒数和z₁₁＝1332.16054，z＝z₁₁＝1332.16054，并将z₁₁存入z₁，z₁＝{z₁₁}＝{1332.16054}；j++，执行3)；

3)判断j是否小于等于n：2<5，执行4)；

4)根据欧氏距离公式计算x₁₂与D₁中其他故障训练数据之间的欧式距离distance(x₁₂,x_1r)，r＝1,3,4,5，将distance(x₁₂,x_1r)存入距离集d₂，d₂＝{distance(x₁₂,x₁₁),distance(x₁₂,x₁₃),distance(x₁₂,x₁₄),distance(x₁₂,x₁₅)}＝{0.0012246332,0.0012696498,0.0099864033,0.0249125219}，并对d₂进行升序排列， d₂＝{0.0012246332,0.0012696498,0.0099864033,0.0249125219}；

5)提取d₂中前3个值{0.0012246332,0.0012696498,0.0099864033}，计算其倒数和z₁₂＝1704.32586；z＝z₁₁+z₁₂＝3036.48641，并将z₁₂存入z₁， z₁＝{z₁₁,z₁₂}＝{1332.16054,1704.32586}；j++，执行3)；

3)判断j是否小于等于n：3<5，执行4)

4)根据欧氏距离公式计算x₁₃与D₁中其他故障训练数据之间的欧式距离distance(x₁₃,x_1r)，r＝1,2,4,5，并将distance(x₁₃,x_1r)存入距离集d₃，d₃＝{distance(x₁₃,x₁₁),distance(x₁₃,x₁₂),distance(x₁₃,x₁₄),distance(x₁₃,x₁₅)}＝{0.0024906719,0.0012696498,0.0112551202,0.0261796716}，并对d₃进行升序排列， d₃＝{0.0012696498,0.0024906719,0.0112551202,0.0261796716}；

5)提取d₃中前3个值{0.0012696498,0.0024906719,0.0112551202}，计算其倒数和z₁₃＝1277.96526，将z₁₃存入z₁，z₁＝{z₁₁,z₁₂,z₁₃}＝{1332.16054,1704.32586,1277.96526}， z＝z₁₁+z₁₂+z₁₃＝4314.45167；j++，执行3)；

3)判断j是否小于等于n：4<5，执行4)；

4)根据欧氏距离公式计算x₁₄与D₁中其他故障训练数据之间的欧式距离distance(x₁₄,x_1r)，r＝1,2,3,5，将distance(x₁₄,x_1r)存入距离集d₄，d₄＝{distance(x₁₄,x₁₁),distance(x₁₄,x₁₂),distance(x₁₄,x₁₃),distance(x₁₄,x₁₅)}＝{0.0087648967,0.0099864033,0.0112551202,0.0149307770}，对d₄进行升序排列， d₄＝{0.0087648967,0.0099864033,0.0112551202,0.0149307770}；

5)提取d₄中前3个值{0.0087648967,0.0099864033,0.0112551202}，计算其倒数和z₁₄＝303.07607，将z₁₄存入z₁，z₁＝{z₁₁,z₁₂,z₁₃,z₁₄}＝ {1332.16054,1704.32586,1277.96526,303.07607}，z＝z₁₁+z₁₂+z₁₃+z₁₄＝4617.52775；j++，执行3)；

3)判断j是否小于等于n：5＝5，执行4)；

4)根据欧氏距离公式计算x₁₅与D₁中其他故障训练数据之间的欧式距离distance(x₁₅,x_1r)，r＝1,2,3,4，将distance(x₁₅,x_1r)存入距离集d₅，d₅＝{distance(x₁₅,x₁₁),distance(x₁₅,x₁₂),distance(x₁₅,x₁₃),distance(x₁₅,x₁₄)}＝{0.0236890962,0.0249125219,0.0261796716,0.0149307770}，并对d₅进行升序排列， d₅＝{0.0149307770,0.0236890962,0.0249125219,0.0261796716}；

5)提取d₄中前3个值{0.0149307770,0.0236890962,0.0249125219}，计算其倒数和z₁₅＝149.32972，将z₁₅存入z₁，z₁＝{z₁₁,z₁₂,z₁₃,z₁₄,z₁₅}＝{1332.16054,1704.32586,1277.96526,303.07607,149.32972}，z＝z₁₁+z₁₂+z₁₃+z₁₄+z₁₅＝4766.85747；j++，执行3)；

3)判断j是否小于等于n：6>5，令j＝1，并执行6)；

6)判断j是否小于等于n：1<5，执行7)；

7)根据公式计算D₁中x₁₁的密度density(x₁₁)＝0.27946，并存入 G₁＝{density(x₁₁)}＝{0.279463}，j++，执行6)；

6)判断j是否小于等于n：2<5，执行7)；

7)根据公式计算D₁中x₁₂的密度density(x₁₂)＝0.35753，并存入G₁＝{density(x₁₁),density(x₁₂)}＝{0.27946,0.35753}，j++，执行6)；

6)判断j是否小于等于n：3<5，执行7)；

7)根据公式计算D₁中x₁₃的密度density(x₁₃)＝0.26809，并存入 G₁＝{density(x₁₁),density(x₁₂),density(x₁₃)}＝{0.27946,0.35753,0.26809}，j++，执行6)；

6)判断j是否小于等于n：4<5，执行7)；

7)根据公式计算D₁中x₁₄的密度density(x₁₄)＝0.06357，并存入 G₁＝{density(x₁₁),density(x₁₂),density(x₁₃),density(x₁₄)}＝{0.27946,0.35753,0.26809,0.0635 7}，j++，执行6)；

6)判断j是否小于等于n：5＝5，执行7)；

7)根据公式计算D₁中x₁₅的密度density(x_ij)＝0.03132，并存入 G₁＝{density(x₁₁),density(x₁₂),density(x₁₃),density(x₁₄),density(x₁₅)}＝{0.27946,0.35753,0.2 6809,0.06357,0.03132}，j++，执行6)；

6)判断j是否小于等于n：6>5，对G₁降序排列，G₁＝{density(x₁₂),density(x₁₁),density(x₁₃),density(x₁₄),density(x₁₅)}＝{0.35753,0.27946,0.26809,0.06357,0.03132}，执行8)；

8)提取G₁中最大密度(G₁中第一个值)所对应的云计算故障训练数据x_max； x_max＝x₁₂＝[0.011292338,0.18902111,0.0061000003,7.6723273E-7,1]，计算x_max与D₁中其他故障训练数据的欧氏距离d_max， d_max＝{distance(x₁₂,x₁₁),distance(x₁₂,x₁₃),distance(x₁₂,x₁₄),distance(x₁₂,x₁₅)}＝{0.001224,0.0 0126,0.00998,0.02491}，并获取d_max最小值对应的云计算故障训练数据x_min； x_min＝x₁₁＝[0.010025084,0.18909907,0.0061000003,2.558721E-7,1]；

9)根据公式a_i＝0.6*x_max+0.4*x_min计算得到球中心a₁＝0.6*x₁₂+0.4*x₁₁； a₁＝[0.0117816684,0.189043738,0.0061000003,7.67386142E-7,1]，并存入Centroids；Centroids＝{[0.0117816684,0.189043738,0.0061000003,7.67386142E-7,1]}

10)计算a₁与D₁中故障训练数据的欧式距离 {7.347799E-4,4.89853E-4,0.0017574557,0.0094977040,0.0244231371}，并计算距离的平均值aver(D₁)＝0.007380586，令最小球半径调节系数coefR＝0.13，根据公式计算最小球半径R₁＝0.0059872134。并存入Radious中； Radious＝{0.0059872134}；令j＝1，并执行11)；

11)判断j是否小于等于n：1<5，执行12)；

12)根据公式计算数据x₁₁与球中心a₁的欧式距离distance(a₁,x₁₁)＝7.34779E-4；

13)判断数据x₁₁与球中心a₁的欧式距离是否小于R₁：7.34779E-4<0.0059872134，执行14)；

14)根据公式计算x₁₁的隶属度ms₁₁，并存入ms₁，ms₁₁＝0.868828203，ms₁＝{ms₁₁}＝{0.868828203}，j++.执行11)；

11)判断j是否小于等于n：2<5，执行12)；

12)根据公式计算数据x₁₂与球中心a₁的欧式距离distance(a₁,x₁₂)＝4.89853E-4；

13)判断数据x₁₂与球中心a₁的欧式距离是否小于R₁：4.89853E-4<0.0059872134，执行14)；

14)根据公式计算x₁₂的隶属度ms₁₂，并存入ms₁，ms₁₂＝0.909245343，ms₁＝{ms₁₁,ms₁₂}＝{0.868828203,0.909245343}，j++.执行11)；

11)判断j是否小于等于n：3<5，执行12)；

12)根据公式计算数据x₁₃与球中心a₁的欧式距离distance(a₁,x₁₃)＝0.0017574557；

13)判断数据x₁₃与球中心a₁的欧式距离是否小于R₁： 0.0017574557<0.0059872134,执行14)；

14)根据公式计算x₁₃的隶属度ms₁₃，并存入ms₁，ms₁₃＝0.727690516，ms₁＝{ms₁₁,ms₁₂,ms₁₃}＝{0.868828203,0.909245343,0.727690516}，j++，执行11)；

11)判断j是否小于等于n：4<5，执行12)；

12)根据公式计算数据x₁₄与球中心a₁的欧式距离distance(a₁,x₁₄)＝0.0094977040；

13)判断数据x₁₄与球中心a₁的欧式距离是否小于R₁： 0.0094977040>0.0059872134，执行15)；

15)根据公式计算x₁₄的隶属度ms₁₄，并存入ms₁，ms₁₄＝0.398600716，ms₁＝{ms₁₁,ms₁₂,ms₁₃,ms₁₄}＝{0.868828203,0.909245343,0.727690516,0.398600716}，j++，执行11)；

11)判断j是否小于等于n：5＝5，执行12)；

12)根据公式计算数据x₁₅与球中心a₁的欧式距离distance(a₁,x₁₅)＝0.0244231371；

13)判断数据x₁₅与球中心a₁的欧式距离是否小于R₁： 0.0244231371>0.0059872134，执行15)；

15)根据公式计算x₁₅的隶属度ms₁₅，并将 ms₁₅存入ms₁，ms₁₅＝0.390463653,ms₁＝{ms₁₁,ms₁₂,ms₁₃,ms₁₄,ms₁₅}＝ {0.868828203,0.909245343,0.727690516,0.398600716,0.390463653}，j++，执行11)；

11)判断j是否小于等于n：6>5，将ms₁存入ms，ms＝{ms₁}＝

{{ms₁₁,ms₁₂,ms₁₃,ms₁₄,ms₁₅}}＝{{0.868828203,0.909245343,0.727690516,0.398600716,0.390463653} }，i++，执行2)；

2)判断i是否小于等于m：2＝2，提取D₂中的故障训练数据，令j＝1；

3)判断j是否小于等于n：1<5，执行4)；

4)根据欧式距离公式计算x₂₁与D₂中其他故障训练数据之间的欧式距离distance(x₂₁,x_2r)，r＝2,3,4,5，将distance(x₂₁,x_2r)存入d₁， d₁＝{distance(x₂₁,x₂₂),distance(x₂₁,x₂₃),distance(x₂₁,x₂₄),distance(x₂₁,x₂₅)}＝{0.0018462596, 0.0029707165,0.0063495094,0.0992002825}；并对d₁进行升序排列，d₁＝{0.0018462596, 0.0029707165,0.0063495094,0.0992002825}；

5)提取d₁中前3个值{0.0018462596,0.0029707165,0.0063495094}，计算其倒数和z₂₁＝1035.74723；z＝z₂₁＝1035.74723；并将z₂₁存入z₂，z₂＝{1035.74723}；j++，执行3)；

3)判断j是否小于等于n：2<5，执行4)；

4)根据欧氏距离公式计算x₂₂与D₂中其他故障训练数据之间的欧式距离distance(x₂₂,x_2r)，r＝1,3,4,5，将distance(x₂₂,x_2r)存入d₂， d₂＝{distance(x₂₂,x₂₁),distance(x₂₂,x₂₃),distance(x₂₂,x₂₄),distance(x₂₂,x₂₅)}＝{0.0018462596, 0.003854735,0.007045077,0.0994709533}；并对d₂进行升序排， d₂＝{0.0018462596,0.003854735,0.007045077,0.0994709533}；

5)提取d₂中前3个值{0.0018462596,0.003854735,0.007045077}，计算其倒数和z₂₂＝942.99988；z＝z₂₁+z₂₂＝1978.74711；并将z₂₂存入z₂中，z₂＝{1035.74723，942.99988}；j++，执行3)；

3)判断j是否小于等于n：3<5，执行4)；

4)根据欧氏距离公式计算x₂₃与D₂中其他故障训练数据之间的欧式距离distance(x₂₃,x_2r)，将distance(x₂₃,x_2r)存入d₃， d₃＝{distance(x₂₃,x₂₁),distance(x₂₃,x₂₂),distance(x₂₃,x₂₄),distance(x₂₃,x₂₅)}＝{0.0029707165,0.0038547355,0.0033792762,0.1019053387}；并对d₃进行升序排列， d₃＝{0.0029707165,0.0038547355,0.0033792762,0.1019053387}；

5)提取d₃中前3个值{0.0029707165,0.0038547355,0.0033792762}，计算其倒数和z₂₃＝891.96164；z＝z₂₁+z₂₂+z₂₃＝2870.70875；将z₂₃存入z₂中，z₂＝{1035.74723，942.99988,891.96164}；j++，执行3)；

3)判断j是否小于等于n：4<5，执行4)；

4)根据欧氏距离公式计算x₂₄与D₂中其他故障训练数据之间的欧式距离distance(x₂₄,x_2r)，将distance(x₂₄,x_2r)存入d₄， d₄＝{distance(x₂₄,x₂₁),distance(x₂₄,x₂₂),distance(x₂₄,x₂₃),distance(x₂₄,x₂₅)}＝{0.0063495094,0.0070450772,0.0033792762,0.1049720657}；并对d₄进行升序排列， d₄＝{0.0033792762,0.0063495094,0.0070450772,0.1049720657}；

5)提取d₄中前3个值{0.0033792762,0.0063495094,0.0070450772}，计算其倒数和z₂₄＝595.35692；z＝z₂₁+z₂₂+z₂₃+z₂₄＝3466.06568；将z₂₄存入z₂中， z₂＝{1035.74723,942.99988,891.96164,595.35692}；j++，执行3)；

3)判断j是否小于等于n：5＝5，执行4)；

4)根据欧氏距离公式计算x₂₅与D₂中其他故障训练数据之间的欧式距离distance(x₂₅,x_2r)，将distance(x₂₅,x_2r)存入d₅， d₅＝{distance(x₂₅,x₂₁),distance(x₂₅,x₂₂),distance(x₂₅,x₂₃),distance(x₂₅,x₂₄)}＝{0.0992002825,0.0994709533,0.1019053387,0.1049720657}；并对d₅进行升序排列， d₅＝{0.0992002825,0.0994709533,0.1019053387,0.1049720657}；

5)提取d₅中前3个值{0.0992002825,0.0994709533,0.1019053387}，计算其倒数和z₂₅＝29.94683，z＝z₂₁+z₂₂+z₂₃+z₂₄+z₂₅＝3496.01251，并将z₂₅存入z₂中，z₂＝{1035.74723,942.99988,891.96164,595.35692,29.94683}；j++，执行3)；

3)判断j是否小于等于n：6>5，令j＝1，并执行6)；

6)判断j是否小于等于n：1<5，执行7)；

7)根据公式计算D₂中x₂₁的密度density(x₂₁)＝0.29626，并将density(x₂₁)存入G₂，G₂＝{density(x₂₁)}＝{0.29626}，j++，执行6)；

6)判断j是否小于等于n：2<5，执行7)；

7)根据公式计算D₂中x₂₂的密度density(x₂₂)＝0.2697358426，并将density(x₂₂)存入G₂，G₁＝{density(x₂₁),density(x₂₂)}＝{0.29626,0.26973}，j++，执行6)；

6)判断j是否小于等于n：3<5，执行7)；

7)根据公式计算D₂中x₂₃的密度density(x₂₃)＝0.255136856，并将density(x₂₃)存入G₂，G₂＝{density(x₂₁),density(x₂₂),density(x₂₃)}＝{0.2962653114,0.2697358426,0.2551368564}，j++，执行6)；

6)判断j是否小于等于n：4<5，执行7)；

7)根据公式计算D₁中x₂₄的密度density(x₂₄)＝0.1702959928并将density(x₂₄)存入G₂，G₂＝{density(x₂₁),density(x₂₂),density(x₂₃),density(x₂₄)}＝{0.2962653114,0.2697358426,0.2551368564,0.1702959928}，j++，执行6)；

6)判断j是否小于等于n：5＝5，执行7)；

7)根据公式计算D₁中x₂₅的密度density(x₂₅)＝0.0085659965，并将density(x₂₅)存入G₂，G₂＝{density(x₂₁),density(x₂₂),density(x₂₃),density(x₂₄),density(x₂₅)}＝{0.2962653114,0.2697358426,0.2551368564,0.1702959928,0.0085659965} ，j++，执行6)；

6)判断j是否小于等于n：6>5，对G₂降序排列， G₂＝{density(x₂₁),density(x₂₂),density(x₂₃),density(x₂₄),density(x₂₅)}＝{0.2962653114,0.269 7358426,0.2551368564,0.1702959928,0.0085659965}，并执行8)；

8)提取G₂中最大密度(G₂中第一个值)所对应的云计算故障训练数据x_max； x_max＝x₂₁＝[0.11500001,0.2757709,0.6922,5.12E-7,2]，计算x_max与D₂中其他故障训练数据的欧氏距离d_max,d_max＝{distance(x₂₁,x₂₁),distance(x₂₁,x₂),distance(x₂₁,x₂₄), distance(x₂₁,x₂₅)}＝{0.0018462596,0.00297071655,0.00634950940,0.09920028255}，并获取d_max中最小距离对应的云计算故障训练数据x_min， x_mim＝x₂₂＝[0.115143955,0.27486098,0.6906,7.6761626E-7,2]；

9)根据公式a_i＝0.6*x_max+0.4*x_min计算得到球中心a₂＝0.6*x₂₁+0.4*x₂₂； a₂＝[0.115057588,0.275406932,0.69156,6.14246504E-7,2]，并存入Centroids中；Centroids＝{a₁,a₂}＝{[0.0117816684,0.189043738,0.0061000003,7.67386142E-7,1],[0.011 7816684,0.189043738,0.0061000003,7.67386142E-7,2]}

10)计算a₂与D₂中故障训练数据的欧式距离{7.38503E-4, 0.0011077557,0.0032280964,0.0065745665,0.0993045204}，并计算距离的平均值 aver(D₂)＝0.0221906886，令最小球半径调节系数coefR＝0.13，根据公式计算最小球半径R₂＝0.0180013335。并存入Radious； Radious＝{R₁,R₂}＝{0.0059872134,0.0180013335}；令j＝1，并执行11)；

11)判断j是否小于等于n：1<5，执行12)；

12)根据公式计算数据x₂₁与球中心a₂的欧式距离distance(a₂,x₂₁)＝7.38503E-4；

13)判断数据x₂₁与球中心a₂的欧式距离是否小于R₂：7.38503E-4<0.0180013335，执行14)；

14)根据公式计算x₂₁的隶属度ms₂₁，并存入ms₂，ms₂₁＝0.952710122，ms₂＝{ms₂₁}＝{0.952710122}，j++，执行11)；

11)判断j是否小于等于n：2<5，执行12)；

12)根据公式计算数据x₂₂与球中心a₂的欧式距离distance(a₂,x₂₂)＝0.0011077557；

13)判断数据x₂₂与球中心a₂的欧式距离是否小于R₂： 0.0011077557<0.0180013335,执行14)；

14)根据公式计算x₂₂的隶属度ms₂₂，并存入ms₂，ms₂₂＝0.930435882，ms₂＝{ms₁₁,ms₁₂}＝{0.952710122,0.930435882}，j++，执行11)；

11)判断j是否小于等于n：3<5，执行12)；

12)根据公式计算数据x₂₃与球中心a₂的欧式距离distance(a₂,x₂₃)＝0.0032280964；

13)判断数据x₂₃与球中心a₂的欧式距离是否小于R₂： 0.0032280964<0.0180013335，执行14)；

14)根据公式计算x₂₃的隶属度ms₂₃，并存入ms₂，ms₂₃＝0.817530864，ms₂＝{ms₂₁,ms₂₂,ms₂₃}＝{0.952710122,0.930435882,0.817530864}，j++，执行11)；

11)判断j是否小于等于n：4<5，执行12)；

12)根据公式计算数据x₂₄与球中心a₂的欧式距离distance(a₂,x₂₄)＝0.00657456654；

13)判断数据x₂₄与球中心a₂的欧式距离是否小于R₂： 0.00657456654<0.0180013335，执行15)；

15)根据公式计算x₂₄的隶属度ms₂₄，并存入ms₂，ms₂₄＝0.678974937，ms₂＝{ms₂₁,ms₂₂,ms₂₃,ms₂₄}＝{0.952710122,0.930435882,0.817530864,0.678974937}，j++，执行11)；

11)判断j是否小于等于n：5＝5，执行12)；

12)根据公式计算数据x₂₅与球中心a₂的欧式距离distance(a₂,x₂₅)＝0.0993045204；

13)判断数据x₂₅与球中心a₂的欧式距离是否小于R₂： 0.0993045204>0.0180013335，执行15)；

15)根据公式计算x₂₅的隶属度ms₂₅，并存入ms₂，ms₂₅＝0.369924,ms₂＝{ms₂₁,ms₂₂,ms₂₃,ms₂₄,ms₂₅}＝{0.952710122,0.930435882,0.817530864,0.678974937,0.369924}，j++.执行11)；

11)判断j是否小于等于n：6>5，将ms₂存入ms，ms＝{ms₁， ms₂}＝{{ms₁₁,ms₁₂,ms₁₃,ms₁₄,ms₁₅},{ms₂₁,ms₂₂,ms₂₃,ms₂₄,ms₂₅}}＝{{0.868828203,0.909245 343,0.727690516,0.398600716,0.390463653},{0.952710122,0.930435882,0.817530864,0 .678974937,0.369924}}，i++，执行2)；

2)判断i是否小于等于m：3>2，输出Centroids、Radious和ms，并执行Step1.3；Centroids＝{a₁,a₂}＝{[0.0117816684,0.189043738,0.0061000003,7.67386142E-7,1],[0.01 17816684,0.189043738,0.0061000003,7.67386142E-7,2]}；Radious＝{R₁,R₂}＝{0.0059872134,0.0180013335}；ms＝{ms₁ms₂}＝{{ms₁₁,ms₁₂,ms₁₃,ms₁₄,ms₁₅}, {ms₂₁,ms₂₂,ms₂₃,ms₂₄,ms₂₅}}＝{{0.868828203,0.909245343,0.727690516,0.398600716,0.390463653},{0.952710122,0.930435882,0.817530864,0.678974937,0.369924}}；

Step1.3：根据云计算故障训练数据故障特征的模糊熵值来计算每个故障类别的特征权重w_i，w_i＝{w_i1,…,w_il,…,w_ip}，并将w_i存入w，w＝{w₁,…,w_i,…,w_m}；

具体的方法：

1)初始化：i＝1，w为空，id为空；

2)判断i是否小于等于2：1<2，执行3)；

3)提取D₁中的故障训练数据，根据公式计算第1个故障类别的理想故障训练数据id₁＝[id₁₁,id₁₂,id₁₃,id₁₄]，并将id₁存入id；令j＝1，并执行4)；

id₁＝[0.018262887,0.18902105,0.00607462079,0.00000056276518,1]，

id＝{id₁}＝{[0.018262887,0.18902105,0.00607462079,0.00000056276518,1]}；

4)判断j是否小于等于5：1<5，获取x₁₁＝ [0.012515664,0.18907768,0.0061037003,7.6761626E-7,2]，令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₁₁的第1故障特征x₁₁₁与理想故障训练数据id₁的第1个故障特征id₁₁的相似度sim₁(1,1)＝0.99991155，并将其存入s₁₁，s₁₁＝{sim₁(1,1)}＝{0.99991155}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₁₁的第2故障特征x₁₁₂与理想故障训练数据id₁的第2个故障特征id₁₂的相似度sim₂(1,1)＝0.999989294，并将其存入s₁₁，s₁₁＝{sim₁(1,1),sim₂(1,1)}＝{0.99991155,0.999989294}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₁₁的第3故障特征x₁₁₃与理想故障训练数据id₁的第3个故障特征id₁₃的相似度sim₃(1,1)＝0.99999969882，并将其存入s₁₁，s₁₁＝{sim₁(1,1),sim₂(1,1),sim₃(1,1)}＝{0.99991155,0.999989294, 0.99999969882}；l++，执行5)；

5)判断l是否小于等于4：4＝4,执行6)；

6)根据相似度公式计算x₁₁的第4故障特征x₁₁₄与理想故障训练数据id₁的第4个故障特征id₁₄的相似度sim₄(1,1)＝0.999999898，并将其存入s₁₁，s₁₁＝{sim₁(1,1),sim₂(1,1),sim₃(1,1),sim₄(1,1}＝{0.99991155, 0.999989294,0.99999969882,0.999999898}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₁₁存入s₁，s₁＝{s₁₁}；j++，执行4)；

4)判断j是否小于等于5：2<5,获取x₁₂＝ [0.011292338,0.18902111,0.0060902003,7.6723273E-7,1]；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4,执行6)；

6)根据相似度公式计算x₁₂的第1故障特征x₁₂₁与理想故障训练数据id₁的第1个故障特征id₁₁的相似度sim₁(1,2)＝0.999896987，并将其存入s₁₂，s₁₂＝{sim₁(1,2)}＝{0.999896987}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₁₂的第2故障特征x₁₂₂与理想故障训练数据id₁的第2个故障特征id₁₂的相似度sim₂(1,2)＝0.999999989，并将其存入s₁₂，s₁₂＝{sim₁(1,2),sim₂(1,2)}＝{0.999896987,0.999999989}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₁₂的第3故障特征x₁₂₃与理想故障训练数据id₁的第3个故障特征id₁₃的相似度sim₃(1,2)＝0.99999982574，并将其存入s₁₂，s₁₂＝{sim₁(1,2),sim₂(1,2),sim₃(1,2)}＝{0.999896987,0.999999989, 0.99999982574}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₁₂的第4故障特征x₁₂₄与理想故障训练数据id₁的第4个故障特征id₁₄的相似度sim₄(1,2)＝0.999999898，并将其存入s₁₂，s₁₂＝{sim₁(1,2),sim₂(1,2),sim₃(1,2),sim₄(1,2)}＝{0.999896987,0.999999989,0.99999982574,0.999999898}；l++，执行5)；

5)判断l是否小于等于4：5>4,将s₁₂存入s₁，s₁＝{s₁₁,s₁₂}，j++，执行4)；

4)判断j是否小于等于5：3<5，获取x₁₃＝[0.010025084,0.18909907,0.0061072803,2.558721E-7,1]；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₁₃的第1故障特征x₁₃₁与理想故障训练数据id₁的第1个故障特征id₁₁的相似度sim₁(1,3)＝0.999883478，并将其存入s₁₃，s₁₃＝{sim₁(1,3)}＝{0.999883478}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₁₃的第2故障特征x₁₃₂与理想故障训练数据id₁的第2个故障特征id₁₂的相似度sim₂(1,3)＝0.999985249，并将其存入s₁₃，s₁₃＝{sim₁(1,3),sim₂(1,3)}＝{0.999883478,0.999985249}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₁₃的第3故障特征x₁₃₃与理想故障训练数据id₁的第3个故障特征id₁₃的相似度sim₃(1,3)＝0.99999978425，并将其存入s₁₃，s₁₃＝{sim₁(1,3),sim₂(1,3),sim₃(1,3)}＝{0.999883478, 0.999985249,0.99999978425}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₁₃的第4故障特征x₁₃₄与理想故障训练数据id₁的第4个故障特征id₁₄的相似度sim₄(1,3)＝0.999999847，并将其存入s₁₃，s₁₃＝{sim₁(1,3),sim₂(1,3),sim₃(1,3),sim₄(1,3)}＝{0.999883478, 0.999985249,0.99999978425,0.999999847}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₁₃存入s₁，s₁＝{s₁₁,s₁₂,s₁₃}，j++,执行4)；

4)判断j是否小于等于5：4<5，获取x₁₄＝ {0.021276593,0.18881398,0.0061000003,2.558721E-7,1}；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₁₄的第1故障特征x₁₄₁与理想故障训练数据id₁的第1个故障特征id₁₁的相似度sim₁(1,4)＝0.999940418，并将其存入s₁₄，s₁₄＝{sim₁(1,4)}＝{0.999940418}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₁₄的第2故障特征x₁₄₂与理想故障训练数据id₁的第2个故障特征id₁₂的相似度sim₂(1,4)＝0.99996088，并将其存入s₁₄，s₁₄＝{sim₁(1,4),sim₂(1,4)}＝{0.999940418,0.99996088}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₁₄的第3故障特征x₁₄₃与理想故障训练数据id₁的第3个故障特征id₁₃的相似度sim₃(1,4)＝0.99999955275，并将其存入s₁₄，s₁₄＝{sim₁(1,4),sim₂(1,4),sim₃(1,4)}＝{0.999940418,0.99996088, 0.99999955275}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₁₄的第4故障特征x₁₄₄与理想故障训练数据id₁的第4个故障特征id₁₄的相似度sim₄(1,4)＝0.999999847，并将其存入s₁₄，s₁₄＝{sim₁(1,4),sim₂(1,4),sim₃(1,4),sim₄(1,4)}＝{0.999940418,0.99996088,0.99999955275,0.999999847}；l++，执行5)；

5)判断l是否小于等于4：5>4,将s₁₄存入s₁，s₁＝{s₁₁,s₁₂,s₁₃,s₁₄}，j++,执行4)；

4)判断j是否小于等于5：5＝5，获取x₁₅＝[0.036204755,0.18909341,0.0061008203,7.6723273E-7,1]；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₁₅的第1故障特征x₁₅₁与理想故障训练数据id₁的第1个故障特征id₁₁的相似度sim₁(1,5)＝0.999511255，并将其存入s₁₅，s₁₅＝{sim₁(1,5)}＝{0.999511255}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₁₅的第2故障特征x₁₅₂与理想故障训练数据id₁的第2个故障特征id₁₂的相似度sim₂(1,5)＝0.99998632，并将其存入s₁₅，s₁₅＝{sim₁(1,5),sim₂(1,5)}＝{0.999511255,0.99998632}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₁₅的第3故障特征x₁₅₃与理想故障训练数据id₁的第3个故障特征id₁₃的相似度sim₃(1,5)＝0.99999980694，并将其存入s₁₅，s₁₅＝{sim₁(1,5),sim₂(1,5),sim₃(1,5)}＝{0.999511255, 0.99998632,0.99999980694}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₁₅的第4故障特征x₁₅₄与理想故障训练数据id₁的第4个故障特征id₁₄的相似度sim₄(1,5)＝0.999999898，并将其存入s₁₅，s₁₅＝{sim₁(1,5),sim₂(1,5),sim₃(1,5),sim₄(1,5)}＝{0.999511255, 0.99998632,0.99999980694,0.999999898}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₁₅存入s₁，j++，并执行4)；

s₁＝{s₁₁,s₁₂,s₁₃,s₁₄,s₁₅}

＝{{sim₁(1,1),sim₂(1,1),sim₃(1,1),sim₄(1,1)},

{sim₁(1,2),sim₂(1,2),sim₃(1,2),sim₄(1,2)},

{sim₁(1,3),sim₂(1,3),sim₃(1,3),sim₄(1,3)},

{sim₁(1,4),sim₂(1,4),sim₃(1,4),sim₄(1,4)},

{sim₁(1,5),sim₂(1,5),sim₃(1,5),sim₄(1,5)}}

＝{{0.99991155,0.999989294,0.99999969882,0.999999898},

{0.999896987,0.999999989,0.99999982574,0.999999898},

{0.999883478,0.999985249,0.99999978425,0.999999847},

{0.999940418,0.99996088,0.99999955275,0.999999847},

{0.999511255,0.99998632,0.99999980694,0.9999998981}}；

4)判断j是否小于等于5：6>5，令l＝1，并执行7)；

7)判断l是否小于等于p：1<4，执行8)；

8)根据s₁和公式计算D₁中数据故障特征的模糊熵值H(1)＝0.0034693421，并计算H_sum＝1/H(1)， H_sum＝288.2390955，l++，并执行7)；

7)判断l是否小于等于p：2<4，执行8)；

8)根据s₁和公式计算D₁中数据故障特征的模糊熵值H(2)＝0.000397521，并计算 H_sum＝1/H(1)+1/H(2)＝2803.8299605，l++，并执行7)；

7)判断l是否小于等于p：3<4，执行8)；

8)根据s₁和公式计算D₁中数据故障特征的模糊熵值H(3)＝0.0000092943，并计算 H_sum＝1/H(1)+1/H(2)+1/H(3)＝110395.7295805，l++，并执行7)；

7)判断l是否小于等于p：4＝4，执行8)；

8)根据s₁和公式计算D₁中数据故障特征的模糊熵值H(4)＝0.00000450297，并计算 H_sum＝1/H(1)+1/H(2)+1/H(3)+1/H(4)＝332471.3515605，l++，并执行7)；

7)判断l是否小于等于p：5>4，令l＝1，并执行9)；

9)判断l是否小于等于p：1<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₁₁＝0.0008132927，并将w₁₁存入w₁，w₁＝{w₁₁}＝{0.0008669591}；l++，执行9)；

9)判断l是否小于等于p：2<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₁₂＝0.0075663387，并将w₁₂存入w₁，w₁＝{w₁₁,w₁₂}＝{0.0008669591,0.0075663387}；l++，执行9)；

9)判断l是否小于等于p：3<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₁₃＝0.323612543，并将w₁₃存入w₁，w₁＝{w₁₁,w₁₂,w₁₃}＝{0.0008669591,0.0075663387,0.323612543}；l++，执行9)；

9)判断l是否小于等于p：4＝4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₁₄＝0.667954159，并将w₁₄存入w₁，w₁＝{w₁₁,w₁₂,w₁₃,w₁₄}＝{0.0008669591,0.0075663387,0.323612543,0.667954159}；l++，执行9)；

9)判断l是否小于等于p：5>4，将w₁存入w， w＝{w₁}＝{{0.0008669591,0.0075663387,0.323612543,0.667954159}},将id₁存入id， id＝{[id₁]}＝{[0.018262887,0.18902105,0.00607462079,0.00000056276518,1]}，i++，执行2)；

2)判断i是否小于等于2：2＝2，执行3)；

3)提取D₁中的故障训练数据数据，根据公式计算数据的均值id₂＝[id₂₁,id₂₂,id₂₃,id₂₄]，并将id₁存入id；

id₂＝[0.09702723,0.274994006,0.69428,0.00000053815658,2]，

id＝{id₁,id₂}＝{[0.018262887,0.18902105,0.00607462079,0.00000056276518,1],[0.09 702723,0.274994006,0.69428,0.00000053815658,2]}；

4)判断j是否小于等于5：1<5，获取x₂₁＝[0.11500001,0.2757709,0.6922,5.12E-7,2]；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₂₁的第1故障特征x₂₁₁与理想故障训练数据id₂的第1个故障特征id₂₁的相似度sim₁(2,1)＝0.998092822，并将其存入s₂₁，s₂₁＝{sim₁(2,1)}＝{0.998092822}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₂₁的第2故障特征x₂₁₂与理想故障训练数据id₂的第2个故障特征id₂₂的相似度sim₂(2,1)＝0.999786034，并将其存入s₂₁，s₂₁＝{sim₁(2,1),sim₂(2,1)}＝{0.999786034,0.999989294}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₂₁的第3故障特征x₂₁₃与理想故障训练数据id₂的第3个故障特征id₂₃的相似度sim₃(2,1)＝0.99855702，并将其存入s₂₁，s₂₁＝{sim₁(2,1),sim₂(2,1),sim₃(2,1)}＝{0.999786034,0.999989294,0.99855702}； l++，执行5)；

5)判断l是否小于等于4：4＝4,执行6)；

6)根据相似度公式计算x₂₁的第4故障特征x₂₁₄与理想故障训练数据id₂的第4个故障特征id₂₄的相似度sim₄(2,1)＝0.999999987，并将其存入s₂₁，s₂₁＝{sim₁(2,1),sim₂(2,1),sim₃(2,1),sim₄(2,1)}＝{0.999786034,0.999989294,0.99855702,0.999999987}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₂₁存入s₂，s₂＝{s₂₁}，j++，执行4)；

4)判断j是否小于等于5：2<5，获取x₂₂＝ [0.115143955,0.27486098,0.6906,7.6761626E-7,2]；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₂₂的第1故障特征x₂₂₁与理想故障训练数据id₂的第1个故障特征id₂₁的相似度sim₁(2,2)＝0.998076226，并将其存入s₂₂，s₂₂＝{sim₁(2,2)}＝{0.998076226}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₂₂的第2故障特征x₂₂₂与理想故障训练数据id₂的第2个故障特征id₂₂的相似度sim₂(2,2)＝0.999963427，并将其存入s₂₂，s₂₂＝{sim₁(2,2),sim₂(2,2)}＝{0.998076226,0.999963427}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₂₂的第3故障特征x₂₂₃与理想故障训练数据id₂的第3个故障特征id₂₃的相似度sim₃(2,2)＝0.997448566，并将其存入s₂₂，s₂₂＝{sim₁(1,2),sim₂(1,2),sim₃(2,2)}＝{0.998076226,0.999963427, 0.997448566}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₂₂的第4故障特征x₂₂₄与理想故障训练数据id₂的第4个故障特征id₂₄的相似度sim₄(2,2)＝0.999999885，并将其存入s₂₂，s₂₂＝{sim₁(1,2),sim₂(1,2),sim₃(1,2),sim₄(2,2)}＝{0.998076226,0.999963427,0.997448566,0.999999885}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₂₂存入s₂，s₂＝{s₂₁,s₂₂}，j++,执行4)；

4)判断j是否小于等于5：3<5,获取x₂₃＝ {0.11779451,0.2758971,0.6932,8.995503E-7,2}；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₂₃的第1故障特征x₂₃₁与理想故障训练数据id₂的第1个故障特征id₂₁的相似度sim₁(2,3)＝0.997766875，并将其存入s₂₃，s₂₃＝{sim₁(2,3)}＝{0.997766875}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₂₃的第2故障特征x₂₃₂与理想故障训练数据id₂的第2个故障特征id₂₂的相似度sim₂(2,3)＝0.999751216，并将其存入s₂₃，s₂₃＝{sim₁(2,3),sim₂(2,3)}＝{0.997766875,0.999751216}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₂₃的第3故障特征x₂₃₃与理想故障训练数据id₂的第3个故障特征id₂₃的相似度sim₃(2,3)＝0.99925048，并将其存入s₂₃，s₂₃＝{sim₁(2,3),sim₂(2,3),sim₃(2,3)}＝{0.997766875,0.999751216,0.99925048}； l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₂₃的第4故障特征x₂₃₄与理想故障训练数据id₂的第4个故障特征id₂₄的相似度sim₄(2,3)＝0.999999819，并将其存入s₂₃，s₂₃＝{sim₁(2,3),sim₂(2,3),sim₃(2,3),sim₄(2,3)}＝{0.997766875,0.999751216,0.99925048,0.999999819}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₂₃存入s₂，s₂＝{s₂₁,s₂₂,s₂₃}，j++,执行4)；

4)判断j是否小于等于5：4<5，获取 x₂₄＝{0.12094766,0.27608985,0.6944,2.558721E-7,2}；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₂₄的第1故障特征x₂₄₁与理想故障训练数据id₂的第1个故障特征id₂₁的相似度sim₁(2,4)＝0.997389566，并将其存入s₂₄，s₂₄＝{sim₁(2,4)}＝{0.997389566}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₂₄的第2故障特征x₂₄₂与理想故障训练数据id₂的第2个故障特征id₂₂的相似度sim₂(2,4)＝0.999698003，并将其存入s₂₄，s₂₄＝{sim₁(2,4),sim₂(2,4)}＝{0.997389566,0.999698003}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₂₄的第3故障特征x₂₄₃与理想故障训练数据id₂的第3个故障特征id₂₃的相似度sim₃(2,4)＝0.999916676，并将其存入s₂₄，s₂₄＝{sim₁(2,4),sim₂(2,4),sim₃(2,4)}＝{0.997389566,0.999698003, 0.999916676}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₂₄的第4故障特征x₂₄₄与理想故障训练数据id₂的第4个故障特征id₂₄的相似度sim₄(2,4)＝0.999999859，并将其存入s₂₄，s₂₄＝{sim₁(2,4),sim₂(2,4),sim₃(2,4),sim₄(2,4)}＝{0.997389566,0.999698003,0.999916676,0.999999859}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₂₄存入s₂，s₂＝{s₂₁,s₂₂,s₂₃,s₂₄}，j++,执行4)；

4)判断j是否小于等于5：5＝5，获取x₂₄＝ {0.016250014,0.2723512,0.701,2.5574423E-7,2}；令l＝1，并执行5)；

5)判断l是否小于等于4：1<4，执行6)；

6)根据相似度公式计算x₂₅的第1故障特征x₂₅₁与理想故障训练数据id₂的第1个故障特征id₂₁的相似度sim₁(2,5)＝0.995414376，并将其存入s₂₅，s₂₅＝{sim₁(2,5)}＝{0.995414376}；l++，执行5)；

5)判断l是否小于等于4：2<4，执行6)；

6)根据相似度公式计算x₂₅的第2故障特征x₂₅₂与理想故障训练数据id₂的第2个故障特征id₂₂的相似度sim₂(2,5)＝0.999276475，并将其存入s₂₅，s₂₅＝{sim₁(2,5),sim₂(2,5)}＝{0.995414376,0.999276475}；l++，执行5)；

5)判断l是否小于等于4：3<4，执行6)；

6)根据相似度公式计算x₂₅的第3故障特征x₂₅₃与理想故障训练数据id₂的第3个故障特征id₂₃的相似度sim₃(2,5)＝0.995300818，并将其存入s₂₅，s₂₅＝{sim₁(2,5),sim₂(2,5),sim₃(2,5)}＝{0.995414376, 0.999276475,0.995300818}；l++，执行5)；

5)判断l是否小于等于4：4＝4，执行6)；

6)根据相似度公式计算x₂₅的第4故障特征x₂₅₄与理想故障训练数据id₂的第4个故障特征id₂₄的相似度sim₄(2,5)＝0.999999859，并将其存入s₂₅，s₂₅＝{sim₁(2,5),sim₂(2,5),sim₃(2,5),sim₄(2,5)}＝{0.995414376, 0.999276475,0.995300818,0.999999859}；l++，执行5)；

5)判断l是否小于等于4：5>4，将s₂₅存入s₂，j++，并执行4)；

s₂＝{s₂₁,s₂₂,s₂₃,s₂₄,s₂₅}

＝{{sim₁(2,1),sim₂(2,1),sim₃(2,1),sim₄(2,1)},

{sim₁(2,2),sim₂(2,2),sim₃(2,2),sim₄(2,2)},

{sim₁(2,3),sim₂(2,3),sim₃(2,3),sim₄(2,3)},

{sim₁(2,4),sim₂(2,4),sim₃(2,4),sim₄(2,4)},

{sim₁(2,5),sim₂(2,5),sim₃(2,5),sim₄(2,5)}}

＝{{0.998092822,0.999786034,0.99855702,0.999999987},

{0.998076226,0.99996342,0.997448566,0.999999885},

{0.997766875,0.999751216,0.99925048,0.999999819},

{0.997389566,0.999698003,0.999916676,0.999999859},

{0.995414376,0.999276475,0.995300818,0.999999859}}；

4)判断j是否小于等于5：6>5，令l＝1，并执行7)；

7)判断l是否小于等于p：1<4，执行8)；

8)根据s₂和公式计算D₂中数据故障特征的模糊熵值H(1)＝0.03954918，并计算H_sum＝1/H(1)＝25.2849743， l++，并执行7)；

7)判断l是否小于等于p：2<4，执行8)；

8)根据s₂和公式计算 D₂中数据故障特征的模糊熵值H(2)＝0.005841478；并计算 H_sum＝1/H(1)+1/H(2)＝196.4744967,l++，并执行7)；

7)判断l是否小于等于p：3<4，执行8)；

8)根据s₂和公式计算D₁中数据故障特征的模糊熵值H(3)＝0.02846794，并计算 H_sum＝1/H(1)+1/H(2)+1/H(3)＝231.60173106,l++，并执行7)；

7)判断l是否小于等于p：4＝4，执行8)；

8)根据s₂和公式计算D₁中数据故障特征的模糊熵值H(4)＝0.0000043085724571，并计算 H_sum＝1/H(1)+1/H(2)+1/H(3)+1/H(4)＝232327.03703106，l++，并执行7)；

7)判断l是否小于等于p：5>4，令l＝1，并执行9)；

9)判断l是否小于等于p：1<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₂₁＝0.0001088335，并将w₂₁存入w₂，w₂＝{w₂₁}＝{0.0001088335}；l++，执行9)；

9)判断l是否小于等于p：2<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₂₂＝0.0007368471，并将w₂₂存入w₂，w₂＝{w₂₁,w₂₂}＝{0.0001088335,0.0007368471}；l++，执行9)；

9)判断l是否小于等于p：3<4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₂₃＝0.0001511973，并将w₂₃存入w₂，w₂＝{w₂₁,w₂₂,w₂₃}＝{0.0001088335,0.0007368471,0.0001511973}；l++，执行9)；

9)判断l是否小于等于p：4＝4，执行10)；

10)根据公式计算D₁中数据故障特征的权重w₂₄＝0.9990031219，并将w₂₄存入w₂，w₂＝{w₂₁,w₂₂,w₂₃,w₂₄}＝{0.0001088335,0.0007368471,0.0001511

973,0.9990031219}；l++，执行9)；

9)判断l是否小于等于p：5>4，将w₂存入w， w＝{w₁,w₂}＝{{0.0008669591,0.0075663387,0.323612543,0.667954159},{0.000108

8335,0.0007368471,0.0001511973,0.9990031219}},将id₂存入id， id＝{id₁,id₂}＝{[0.018262887,0.18902105,0.00607462079,0.00000056276518,1],[0.09702723,0.274994006,0.69428,0.00000053815658,2]}；i++，执行2)；

2)判断i是否小于等于2：3>2，输出w，id；

w＝{w₁,w₂}＝{{0.0008669591,0.0075663387,0.323612543,0.667954159},{0.0001088 335,0.0007368471,0.0001511973,0.9990031219}}，

id＝{id₁,id₂}＝{[0.018262887,0.18902105,0.00607462079,0.00000056276518,1],[0.09 702723,0.274994006,0.69428,0.00000053815658,2]}；执行Step2；

Step2：待检测云计算数据所属故障类别判断；本实例中待检测云计算数据共有 4条，u＝{u₁,u₂,u₃,u₄}，

u₁＝[u₁₁,u₁₂,u₁₃,u₁₄]＝[0.026282847,0.18866992,0.0062,2.5574423E-7]，

u₂＝[u₂₁,u₂₂,u₂₃,u₂₄]＝[0.015037596,0.1886217,0.0062,2.5574423E-7]，

u₃＝[u₃₁,u₃₂,u₃₃,u₃₄]＝[0.11403507,0.2764418,0.6969,7.3443284E-6]，

u₄＝[u₄₁,u₄₂,u₄₃,u₄₄]＝[0.11485642,0.275886,0.6931,2.558721E-6]；

Step2.1：判断q是否小于等于e：1<4，提取 u₁＝[0.026282847,0.18866992,0.0062,2.5574423E-7]，并根据公式计算u₁与D中故障训练数据加权欧式距离，并根据距离升序排列，构建一个集合distanceSet＝{d(x₁₄),d(x₁₅),d(x₁₁), d(x₁₂),d(x₁₃),(x₂₂),d(x₂₁),d(x₂₅),d(x₂₃),d(x₂₄)}＝{1.20822E-15,8.01818E-15,2.80384E-14,3.9 5144E-14,5.70885E-14,5.95285E-09,6.0217E-09,6.06502E-09,6.10912E-09,6.11781E-09 }；

Step2.2：提取distanceSet中2个最小距离 {d(x₁₄),d(x₁₅)}＝{1.20822E-15,8.01818E-15}对应的故障训练数据 x₁₄＝[0.021276593,0.18881398,0.0061000003,2.558721E-7,1]，x₁₅＝[0.036204755, 0.18909341,0.0061000003,7.6723273E-7,1]，并设置阈值σ₁＝0.94，σ₂＝0.4；

Step2.3:根据k个故障训练数据中隶属度最大值Mas_ms对应故障训练数据的类别信息和云计算故障训练数据集扩充规则来确定待检测云计算数据的类别；其中云计算故障训练数据集扩充规则为：①根据Max_ms大于阈值σ₁且待检测云计算数据与Max_ms对应故障训练数据所属故障类别的理想故障训练数据的距离小于匹配阈值ρ来确定将该待检测云计算数据及其类别信息加入已知故障类别扩充集 known_fault；②根据Max_ms小于阈值σ₂来确定待检测云计算数据为未知故障类别并将该数据和其类别信息加入未知故障类别扩充集Unknown_fault；q++，执行 Step2.1；

具体方法：

1)初始化：v＝1，Max_ms＝0；

2)判断v是否小于等于2：1<2，提取第1个近邻数据x₁₄对应的隶属度ms₁＝ ms₁₄＝0.398600716；

3)判断ms_v是否大于等于Max_ms：0.398600716>0,将ms₁的值赋给Max_ms， Max_ms＝0.398600716；并获取近邻数据x₁₄类别信息：2；

2)判断v是否小于等于2：2＝2，提取第2个近邻数据x₁₅对应的隶属度 ms₂＝ms₁₅＝0.390463653；

3)判断ms_v是否大于等于Max_ms：0.390463653<0.398600716，执行2)；

2)判断v是否小于等于2：3>2，并执行4)；

4)判断Max_ms是否大于σ₁：0.398600716<0.94，执行7)；

7)判断Max_ms是否小于σ₂:0.398600716<0.4，将u₁所属故障类别判断为其他未知故障类别，并将u₁及其类别信息加入未知故障类别扩充集Unknown_fault_set＝{0.026282847,0.18866992,0.0062,2.5574423E-7,未知故障}，执行 9)；

9)输出u₁的类别信息：未知故障；

Step2.1：判断q是否小于等于e：2<4，提取 u₂＝[0.015037596,0.1886217,0.0062,2.5574423E-7]，并根据公式计算u₂与D中故障训练数据加权欧式距离，并根据距离距离升序排列，构建一个集合 distanceSet＝{d(x₁₁),d(x₁₂),d(x₁₃),d(x₁₄),d(x₁₅),d(x₂₂),d(x₂₁),d(x₂₃),d(x₂₅),d(x₂₄)}＝{8.02192E- 17,2.68889E-16,1.01730E-15,2.19965E-15,1.54420E-13,5.98954E-09,6.05856E-09,6.103 08E-09,6.10836E-09,6.15725E-09}；

Step2.2:提取distanceSet中2个最小距离{d(x₁₁),d(x₁₂)}＝{8.02192E-17,2.68889E-16} 对应的故障训练数据数据 x₁₁＝[0.012515664,0.18907768,0.0061000003,7.6761626E-7,1]，x₁₂＝[0.011292338, 0.18902111,0.0061000003,7.6723273E-7,1]，并设置阈值σ₁＝0.94，σ₂＝0.4；

具体方法：

1)初始化：v＝1，Max_ms＝0；

2)判断v是否小于等于2：1<2，提取第1个近邻数据x₁₁的隶属度ms₁＝ ms₁₁＝0.868828203；

3)判断ms_v是否大于等于Max_ms：0.868828203>0，将ms₁的值赋给Max_ms， Max_ms＝0.868828203；并获取近邻数据x₁₁类别信息：1；v++，执行2)

2)判断v是否小于等于2：2＝2，提取第2个近邻数据x₁₂对应的隶属度ms₂＝ ms₁₂＝0.909245343；

3)判断ms_v是否大于等于Max_ms：0.909245343<0.868828203，将ms₂的值赋给Max_ms，Max_ms＝0.909245343；并获取近邻数据x₁₂类别信息：1；v++，执行2)；

2)判断v是否小于等于2：3>2，执行4)；

4)判断Max_ms是否大于σ₁：0.909245343<0.94，执行7)；

7)判断Max_ms是否小于σ₂:0.909245343>0.4，执行8)；

8)将u₂所属的故障类别判断为Max_ms对应故障训练数据x₁₂的故障类别，u₂的类别信息：1；

9)输出u₂的类别信息：1；

Step2.1：判断q是否小于等于e：3<4，提取 u₃＝[0.11403507,0.2764418,0.6969,7.3443284E-6]，并根据公式

计算u₁与D中故障训练数据加权欧式距离，并根据距离距离升序排列，构建一个集合distanceSet＝{d(x₂₁),d(x₂₃),d(x₂₄),d(x₂₂),d(x₂₅),d(x₁₁),d(x₁₅),d(x₁₂),d(x₁₃), d(x₁₄)}＝{1.45892E-17,.49629E-17,3.95257E-17,6.43113E-17,1.11425E-12,0.023865727, 0.023867025,0.023868685,0.023877599,0.023882437}；

Step2.2:提取distanceSet中2个最小距离{d(x₂₁), d(x₂₃)}＝{1.45892E-17,1.49629E-17}对应的故障训练数据 x₂₁＝[0.11500001,0.2757709,0.6922,5.12E-7,2]，x₂₃＝[0.11779451,0.275897,1,0.6932, 8.995503E-7,2]，并设置阈值σ₁＝0.94，σ₂＝0.4；

具体方法：

1)初始化：v＝1，Max_ms＝0；

2)判断v是否小于等于2：1<2，提取第1个近邻数据x₂₁的隶属度ms₁＝ms₂₁＝0.952710122；

3)判断ms_v是否大于等于Max_ms：0.952710122>0，将ms₁的值赋给Max_ms， Max_ms＝0.952710122；并获取近邻数据x₂₁类别信息：2；

2)判断v是否小于等于2：2＝2,提取第2个近邻数据x₂₃对应的隶属度 ms₂＝ms₂₃＝0.817530864；

3)判断ms_v是否大于等于Max_ms：0.817530864<0.952710122，执行2)；

2)判断v是否小于等于2：3>2，执行4)；

4)判断Max_ms是否大于σ₁：0.952710122>0.94，提取Max_ms对应故障训练数据所属故障类别c₂的最小球半径R_s＝R₂，R_s＝0.0180013335，执行5)；

5)计算u₃与Max_ms对应故障训练数据x₂₁所对应故障类别的理想故障训练数据id_{Max_ms}＝id₂＝{[0.09702723,0.274994006,0.69428,0.00000053815658,2]}的欧式距离dsim＝0.0172692552，设置匹配阈值ρ＝2R₂＝0.036002667；

6)判断dsim是否小于ρ：0.0172692552<0.033600266，将u₃所属的故障类别判断为Max_ms对应故障训练数据x₂₁的故障类别，u₃的故障类别：2；并将u₃及类别信息加入已知故障类别扩充集 known_fault_set＝{0.11403507,0.2764418,0.6969,7.3443284E-6,2}，并执行9)；

9)输出u3的类别信息：2；

Step2.1：判断q是否小于等于e：4＝4，提取 u₄＝[0.11485642,0.275886,0.6931,2.558721E-6]，并根据公式计算u₁与D中故障训练数据加权欧式距离，并根据距离距离升序排列，构建一个集合distanceSet＝{d(x₂₄),d(x₂₁),d(x₂₃),d(x₂₂),d(x₂₅),d(x₁₁),d(x₁₅),d(x₁₂),d(x₁₃),d(x₁₄)}＝{6.93820E-15,1.00659E-14,1.06183E-14,1.51979E-14,3.70178E-12,2.33471E-02,2.3347 9E-02,2.33500E-02,2.33588E-02,2.33633E-02}；

Step2.2:提取distanceSet中2个最小距离{d(x₂₄),d(x₂₁)}＝{1.45892E-17,1.49629E-17} 对应的故障训练数据x₂₄＝[0.12094766,0.27608985,0.6944,2.558721E-7,2]， x₂₁＝[0.11779451,0.2758971,

0.6932,8.995503E-7,2]，并设置阈值σ₁＝0.94，σ₂＝0.4；

具体方法：

1)初始化：v＝1，Max_ms＝0；

2)判断v是否小于等于2：1<2，提取第1个近邻数据x₂₄的隶属度ms₁＝ms₂₄＝0.678974937；

3)判断ms_v是否大于等于Max_ms：0.678974937>0，将ms₁的值赋给Max_ms， Max_ms＝0.678974937；并获取近邻数据x₂₄类别信息：2；v++,执行2)；

2)判断v是否小于等于2：2＝2，提取第2个近邻数据x₂₁对应的隶属度 ms₂＝ms₂₁＝0.952710122；

3)判断ms_v是否大于等于Max_ms：0.952710122>0.678974937，将ms₂的值赋给Max_ms，Max_ms＝0.952710122；并获取近邻数据x₂₁类别信息：2；v++，执行2)；

2)判断v是否小于等于2：3>2，执行4)；

4)判断Max_ms是否大于σ₁：0.952710122>0.94，提取Max_ms对应故障训练数据所属故障类别的最小球半径R_s＝R₂，R_s＝0.0180013335，设匹配阈值ρ＝2R₂＝0.036002667，并执行5)；

5)计算u₄与Max_ms对应故障训练数据x₂₁所对应故障类别的理想故障训练数据id_{Max_ms}＝id₂＝{[0.09702723,0.274994006,0.69428,0.00000053815658,2]}的欧式距离dsim＝0.0515581936；

6)判断dsim是否小于ρ：0.0515581936>0.033600266，执行8)；

8)将u₄所属的故障类别判断为Max_ms对应故障训练数据x₂₁的故障类别，u₄的类别信息：2；

9)输出u₄的类别信息：2；

Step2.1：判断q是否小于等于e：5>4，执行Step3；

Step3：将known_fault_set和Unknown_fault_set存入云计算故障训练数据扩充集 Ext_D，Ext_D＝{{0.026282847,0.18866992,0.0062,2.5574423E-7,未知},{0.11403507,0.2764418,0.6969,7.3443284E-6,2}}。

上面结合附图对本发明的具体实施方式作了详细说明，但是本发明并不限于上述实施方式，在本领域普通技术人员所具备的知识范围内，还可以在不脱离本发明宗旨的前提下作出各种变化。

Claims

1.一种云计算故障数据检测方法，其特征在于：包括：

2.根据权利要求1所述的云计算故障数据检测方法，其特征在于：所述方法的具体步骤如下：

Step1：云计算故障训练数据处理；

Step1.1：输入含m个故障类别且每个故障类别含有n个故障训练数据的云计算故障训练数据集D＝{D₁,…,D_i,…,D_m}，D_i＝{x_i1,…,x_ij,…,x_in}，x_ij＝[x_ij1,…,x_ijl,…,x_ijp,c_i]，i＝1,2,…,m，j＝1,2,…,n，l＝1,2,…p，其中D_i表示属于第i个故障类别的故障训练数据，x_ij表示D_i中第j条故障训练数据，x_ijl表示D_i中第j条故障训练数据的第l个故障特征，c_i表示x_ij所属故障类别，m表示故障类别数，n表示D_i中故障训练数据个数，p表示故障训练数据的故障特征数；

Step1.3：根据云计算故障训练数据故障特征的模糊熵值来计算每个故障类别的特征权重w_i，w_i＝{w_i1,…,w_il,…,w_ip}，并将w_i存入w，w＝{w₁,…,w_i,…,w_m},其中w表示D中故障训练数据的故障特征权重集合，w_i表示D_i中故障训练数据的故障特征权重，w_il表示第i个故障类别第l个故障特征的权重；

Step2：待检测云计算数据所属故障类别判断；其中待检测云计算数据集用U表示，U＝{u₁,…,u_q,…,u_e}，uq＝{u_q1,…,u_ql,…,u_qp}，其中u_q表示待检测云计算数据集U中第q个云计算数据，u_ql表示U中第q个云计算数据中第l个故障特征，q＝1,2,…,e，e表示待检测云计算数据个数；

Step2.3：根据k个故障训练数据中隶属度最大值Max_ms对应故障训练数据的类别信息和云计算故障训练数据集扩充规则来确定待检测云计算数据的类别；其中云计算故障训练数据集扩充规则为：①根据Max_ms大于阈值σ₁且待检测云计算数据与Max_ms对应故障训练数据所属故障类别的理想故障训练数据的距离小于匹配阈值ρ来确定将该待检测云计算数据及其类别信息加入已知故障类别扩充集known_fault；②根据Max_ms小于阈值σ₂来确定待检测云计算数据为未知故障类别并将该数据和其类别信息加入未知故障类别扩充集Unknown_fault；q++，执行Step2.1；

Step3：云计算故障训练数据集扩充，将满足云计算故障训练集扩充规则的known_fault_set和Unknown_fault_set存入云计算故障训练数据扩充集Ext_D，其中Ext_D用于扩充云计算故障训练数据集D。

3.根据权利要求2所述的云计算故障数据检测方法，其特征在于：所述故障训练数据的隶属度，计算方法为：

<mrow> <mi>d</mi> <mi>i</mi> <mi>s</mi> <mi>tan</mi> <mi>c</mi> <mi>e</mi> <mrow> <mo>(</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>j</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>r</mi> </mrow> </msub> <mo>)</mo> </mrow> <mo>=</mo> <msqrt> <mrow> <munderover> <mo>&Sigma;</mo> <mrow> <mi>l</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>p</mi> </munderover> <msup> <mrow> <mo>(</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>j</mi> <mi>l</mi> </mrow> </msub> <mo>-</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>r</mi> <mi>l</mi> </mrow> </msub> <mo>)</mo> </mrow> <mn>2</mn> </msup> </mrow> </msqrt> <mo>-</mo> <mo>-</mo> <mo>-</mo> <mrow> <mo>(</mo> <mn>1</mn> <mo>)</mo> </mrow> </mrow>

a_i＝0.6*x_max+0.4*x_min(3)

10)计算a_i与D_i中故障训练数据的欧式距离，并求距离平均值aver(D_i)，设置最小球半径调节系数coefR，根据公式(4)计算最小球半径R_i，将R_i存入Radious；令j＝1，并执行11)；

11)判断j是否小于等于n：如果是，执行12)；否则，将ms_i存入ms，ms_i＝{ms_i1,…,ms_ij,…,ms_in}，其中ms_i表示D_i中故障训练数据的隶属度集合，i++，并执行2)；

12)根据公式(5)计算x_ij与球中心a_i的欧式距离distance(a_i,x_ij)；

<mrow> <mi>d</mi> <mi>i</mi> <mi>s</mi> <mi>tan</mi> <mi>c</mi> <mi>e</mi> <mrow> <mo>(</mo> <msub> <mi>a</mi> <mi>i</mi> </msub> <mo>,</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>j</mi> </mrow> </msub> <mo>)</mo> </mrow> <mo>=</mo> <msqrt> <mrow> <munderover> <mo>&Sigma;</mo> <mrow> <mi>l</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>p</mi> </munderover> <msup> <mrow> <mo>(</mo> <msub> <mi>a</mi> <mrow> <mi>i</mi> <mi>l</mi> </mrow> </msub> <mo>-</mo> <msub> <mi>x</mi> <mrow> <mi>i</mi> <mi>j</mi> <mi>l</mi> </mrow> </msub> <mo>)</mo> </mrow> <mn>2</mn> </msup> </mrow> </msqrt> <mo>-</mo> <mo>-</mo> <mo>-</mo> <mrow> <mo>(</mo> <mn>5</mn> <mo>)</mo> </mrow> </mrow>

其中a_il为故障类别i的球中心的第l个故障特征；

4.根据权利要求2所述的云计算故障数据检测方法，其特征在于：所述故障特征的权重，计算方法为：

2)判断i是否小于等于m：如果是，执行3)；否则，输出w和id，id＝{id₁,…,id_i,…,id_m}，其中id为D中每个故障类别的理想故障训练数据的集合，并执行Step2；

6)根据公式(9)计算x_ij第l个故障特征与理想故障训练数据id_i第l个故障特征的相似度sim_l(i,j)，并将其存入s_ij，其中s_ij表示D_i中第j个故障训练数据的故障特征与id_i中对应故障特征的相似度集合；l++，执行5)；

<mrow> <mi>H</mi> <mrow> <mo>(</mo> <mi>l</mi> <mo>)</mo> </mrow> <mo>=</mo> <mo>-</mo> <munderover> <mo>&Sigma;</mo> <mrow> <mi>j</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>n</mi> </munderover> <msub> <mi>sim</mi> <mi>l</mi> </msub> <mrow> <mo>(</mo> <mi>i</mi> <mo>,</mo> <mi>j</mi> <mo>)</mo> </mrow> <msub> <mi>logsim</mi> <mi>l</mi> </msub> <mrow> <mo>(</mo> <mi>i</mi> <mo>,</mo> <mi>j</mi> <mo>)</mo> </mrow> <mo>+</mo> <mrow> <mo>(</mo> <mn>1</mn> <mo>-</mo> <msub> <mi>sim</mi> <mi>l</mi> </msub> <mo>(</mo> <mrow> <mi>i</mi> <mo>,</mo> <mi>j</mi> </mrow> <mo>)</mo> <mo>)</mo> </mrow> <mi>l</mi> <mi>o</mi> <mi>g</mi> <mrow> <mo>(</mo> <mn>1</mn> <mo>-</mo> <msub> <mi>sim</mi> <mi>l</mi> </msub> <mo>(</mo> <mrow> <mi>i</mi> <mo>,</mo> <mi>j</mi> </mrow> <mo>)</mo> <mo>)</mo> </mrow> <mo>-</mo> <mo>-</mo> <mo>-</mo> <mrow> <mo>(</mo> <mn>10</mn> <mo>)</mo> </mrow> </mrow>

9)判断l是否小于等于p：如果是，执行10)；否则，将w_i存入w，w_i＝{w_i1,…,w_il,…,w_ip}，i++，执行2)；

5.根据权利要求2所述的云计算故障数据检测方法，其特征在于：所述判断待检测云计算数据的类别的方法：

1)初始化：v＝1，Max_ms＝0；

<mrow> <mi>d</mi> <mi>s</mi> <mi>i</mi> <mi>m</mi> <mo>=</mo> <msqrt> <mrow> <munderover> <mo>&Sigma;</mo> <mrow> <mi>l</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>p</mi> </munderover> <msup> <mrow> <mo>(</mo> <msub> <mi>u</mi> <mrow> <mi>q</mi> <mi>l</mi> </mrow> </msub> <mo>-</mo> <msub> <mi>id</mi> <mrow> <mi>M</mi> <mi>a</mi> <mi>x</mi> <mo>_</mo> <mi>m</mi> <mi>s</mi> <mi>l</mi> </mrow> </msub> <mo>)</mo> </mrow> <mn>2</mn> </msup> </mrow> </msqrt> <mo>-</mo> <mo>-</mo> <mo>-</mo> <mrow> <mo>(</mo> <mn>12</mn> <mo>)</mo> </mrow> </mrow>

6)判断dsim是否小于等于ρ：如果是，将u_q所属的故障类别判断为Max_ms对应故障训练数据的类别，并将u_q及其类别信息加入已知故障类别扩充集known_fault_set，并执行9)；否则，执行8)；

9)输出u_q的类别信息。

6.根据权利要求2或5所述的云计算故障数据检测方法，其特征在于：所述σ₁＝0.94，σ₂＝0.4，k＝2。

7.根据权利要求3所述的云计算故障数据检测方法，其特征在于：所述K＝3。

8.一种云计算故障数据检测系统，其特征在于：包括：