CN112882887B - 一种云计算环境下服务故障模型动态建立方法 - Google Patents

一种云计算环境下服务故障模型动态建立方法 Download PDF

Info

Publication number
CN112882887B
CN112882887B CN202110033483.5A CN202110033483A CN112882887B CN 112882887 B CN112882887 B CN 112882887B CN 202110033483 A CN202110033483 A CN 202110033483A CN 112882887 B CN112882887 B CN 112882887B
Authority
CN
China
Prior art keywords
executing
list
service
fault
judging
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
CN202110033483.5A
Other languages
English (en)
Other versions
CN112882887A (zh
Inventor
姜瑛
段敏慧
汤守国
李凌宇
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Kunming University of Science and Technology
Original Assignee
Kunming University of Science and Technology
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Kunming University of Science and Technology filed Critical Kunming University of Science and Technology
Priority to CN202110033483.5A priority Critical patent/CN112882887B/zh
Publication of CN112882887A publication Critical patent/CN112882887A/zh
Application granted granted Critical
Publication of CN112882887B publication Critical patent/CN112882887B/zh
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
    • G06F11/3006—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system is distributed, e.g. networked systems, clusters, multiprocessor systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
    • G06F11/302—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is a software system
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/3051—Monitoring arrangements for monitoring the configuration of the computing system or of the computing system component, e.g. monitoring the presence of processing resources, peripherals, I/O links, software programs
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F18/00—Pattern recognition
    • G06F18/20—Analysing
    • G06F18/24—Classification techniques
    • G06F18/241—Classification techniques relating to the classification model, e.g. parametric or non-parametric approaches
    • G06F18/2415—Classification techniques relating to the classification model, e.g. parametric or non-parametric approaches based on parametric or probabilistic models, e.g. based on likelihood ratio or false acceptance rate versus a false rejection rate
    • G06F18/24155—Bayesian classification
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Computing Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Quality & Reliability (AREA)
  • Data Mining & Analysis (AREA)
  • Mathematical Physics (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Evolutionary Computation (AREA)
  • Evolutionary Biology (AREA)
  • Computer Vision & Pattern Recognition (AREA)
  • Bioinformatics & Computational Biology (AREA)
  • Bioinformatics & Cheminformatics (AREA)
  • Artificial Intelligence (AREA)
  • Probability & Statistics with Applications (AREA)
  • Test And Diagnosis Of Digital Computers (AREA)

Abstract

本发明公开了一种云计算环境下服务故障模型动态建立方法，属于云计算下服务故障模型建立领域。所述方法步骤包括：Step1、预处理服务运行数据；Step2、抽取服务故障；Step3、确定服务故障分类；Step4、抽取服务故障特征；Step5、动态关联服务故障与服务故障特征。本发明能动态识别出云计算环境下服务故障与服务故障特征；能通过分析服务故障与服务故障特征间的关联性，建立服务故障与服务故障特征的网状结构，实现服务故障模型的动态演化。

Description

一种云计算环境下服务故障模型动态建立方法
技术领域
本发明涉及一种云计算环境下服务故障模型动态建立方法，属于云计算下服务故障模型建立领域。
背景技术
云计算环境的复杂性、动态性和开放性，使得分布式软件系统的规模和结构日益复杂，系统故障也呈现出了由简单到复杂、由静态到动态、由确定到不确定等特点。为了更好地检测和预防服务故障的发生，需通过构建动态的服务故障模型来辅助分析。高伟鹏提出了基于层级树形结构并采用深度神经网络的故障建模方法，根据故障模型对采集处理后的实时数据判断是否有组件或者服务发生异常情况，并根据检测结果动态自适应更新故障模型。由于原有的故障树无法描述某些不断出现的新的或隐藏的系统故障，刘政提出了采用动态故障树的技术来描述和分析复杂分布式系统故障之间的内在关联关系、时序关系，建立了动态的故障树模型，实现了基于动态故障树的复杂分布式系统故障检测系统，提高了复杂分布式系统故障建模和故障知识积累。黄旭提出了一种新的基于改进型递归神经网络的无线传感器网络动态建模方法并将其应用到故障检测和识别中，采用节点输出值与神经网络输出值进行比对以判断故障是否发生，当有故障发生时，神经网络的权值与故障模型进行比较以隔离故障，如果没有相似的故障则将新故障类型及相应的故障参数更新至故障模型库。针对传统故障诊断模型无法跟踪故障的动态变化问题，闫纪红等人提出了故障诊断模型自动更新的概念，建立了一种基于异常点检测的人工免疫故障诊断模型自动更新算法，该模型能够根据故障类型和特征的改变实现故障模型的自动更新。
上述故障模型动态更新方法通过分析故障与故障之间的关联性，识别出新产生的故障，实现故障模型的自动更新。但是这些方法都忽略了对故障与故障特征间关联关系的分析。众所周知，故障发生时伴随出现的故障特征(故障的具体表现形式)对于故障的检测和诊断至关重要，通过分析它们之间的关联关系能更好的帮助系统管理员定位故障并处理故障。因此，动态关联服务故障与服务故障特征，实现云计算环境下的服务故障模型动态演化成为亟待解决的问题。
发明内容
本发明提供了一种云计算环境下服务故障模型动态建立方法，以用于通过动态方式关联服务故障与服务故障特征。
本发明的技术方案是：一种云计算环境下服务故障模型动态建立方法，所述方法步骤包括：
Step1、预处理服务运行数据：对服务运行数据集进行方差计算，根据方差计算结果删除运行数据集中无效的属性数据列，获得预处理服务运行数据集列表；
Step2、抽取服务故障：对预处理服务运行数据集列表进行服务故障判断，抽取服务故障数据；
Step3、确定服务故障分类：对抽取出的服务故障数据通过多属性的不同表现形式产生不同服务故障的分类方式，对服务故障数据进行分类，并对分类后的服务故障数据进行类别标记；
Step4、抽取服务故障特征：对分类后的服务故障分别抽取服务故障特征，抽取出的服务故障特征代表该类故障发生时所产生的故障表现形式；
Step5、动态关联服务故障与服务故障特征：对分类后的服务故障与已知服务故障进行朴素贝叶斯概率计算，识别出新产生的服务故障；对服务故障中抽取的服务故障特征与已知服务故障特征进行比对，识别出新产生的服务故障特征；分析服务故障与服务故障特征间关联并动态更新已知服务故障与已知服务故障特征间关联。
所述Step1具体如下：
Step1.1、初始化云计算环境下监测到的服务运行数据集D，从服务运行数据集D中提取出服务运行数据存入服务运行数据列表ServiceDataList，ServiceDataListr*c＝[[J1]，[J2]，[J3]，..，[Jr]]，[J1]＝[M1，M2，M3，...，Mc]，其中，J1为第1条服务运行数据，Jr为第r条服务运行数据，Mc为第1条服务运行数据的第c个属性，r为服务运行数据列表中数据总条数，c为每条服务运行数据属性的总数，设置g＝0，h＝0，执行Step1.2；
Step1.2、判断g＜ServiceDataList.get(h).size()，如果是执行Step1.3；否则执行Step2；其中，ServiceDataList.get(h).size()表示二维服务运行数据列表ServiceDataList中第h条服务运行数据属性个数的大小；
Step1.3、初始化一个空列表resultList，此列表用来存放属性列的服务运行数据，执行Step1.4；
Step1.4、判断h＜ServiceDataList.size()，如果是执行Step1.5；否则执行Step1.6；其中，ServiceDataList.size()表示二维服务运行数据列表ServiceDataList的数据总条数大小；
Step1.5、将ServiceDataList.get(h).get(g)存入到列表resultList，h++，执行Step1.4；其中，ServiceDataList.get(h).get(g)表示二维服务运行数据列表ServiceDataList中第h条服务运行数据的第g个属性的值；
Step1.6、设置a＝0，属性列数据总和sum＝0，属性列数据平均值average＝0，属性列数据方差variance＝0，v＝0，判断a＜resultList.size()，如果是执行Step1.7，否则执行Step1.8；其中，resultList.size()表示列表resultList的数据个数的大小；
Step1.7、计算数据总和sum+＝resultList.get(a)，a++，执行Step1.6；其中，resultList.get(a)表示列表resultList中第a个数据的值；
Step1.8、计算数据平均值
Figure BDA0002893219200000021
执行Step1.9；
Step1.9、设置b＝0，执行Step1.10；
Step1.10、判断b＜resultList.size()，如果是执行Step1.11，否则执行Step1.12；
Step1.11、v+＝(resultList.get(b)-average)2，b++，执行Step1.9；
Step1.12、计算方差值
Figure BDA0002893219200000022
判断variance＞0，如果是保留属性列表resultList，并存入预处理服务运行数据集列表，否则删除该属性列表resultList，g++，执行Step1.2。
所述Step2具体如下：
Step2.1、设置s＝0，执行Step2.2；
Step2.2、读取预处理服务运行数据集列表存入二维列表dataList，执行Step2.3；
Step2.3、判断s＜dataList.size()，如果是执行Step2.4；否则执行Step3；其中，dataList.size()表示列表dataList的数据总条数大小；
Step2.4、设置w＝0，执行Step2.5；
Step2.5、判断w＜dataList.get(s).size()，如果是执行Step2.6，否则执行Step2.7；其中，dataList.get(s).size()表示二维列表dataList中第s条服务运行数据属性个数的大小；
Step2.6、判断dataList.get(s).get(w)＞60，如果是执行Step2.8；否则执行Step2.9；其中，dataList.get(s).get(w)表示列表dataList中第s条服务运行数据的第w个属性的值；
Step2.7、dataList.get(s)为正常数据，s++，执行Step2.3；其中，dataList.get(s)表示列表dataList的第s条数据；
Step2.8、dataList.get(s)为故障数据，存入二维列表newFaultdataList，s++，执行Step2.3；
Step2.9、w++，执行Step2.5。
所述Step3具体如下：
Step3.1、设置i＝0，tag＝0，q1＝newFaultdataList.get(i).size()，新建二维列表tempList，执行Step3.2；其中，newFaultdataList.get(i).size()表示二维列表newFaultdataList中第i条服务运行数据属性个数的大小；
Step3.2、读取服务故障数据集二维列表newFaultdataList，执行Step3.3；
Step3.3、判断i＜newFaultdataList.size()，如果是执行Step3.4，否则执行Step4；其中，newFaultdataList.size()表示二维列表newFaultdataList的数据总条数大小；
Step3.4、设置p＝0，q＝1，执行Step3.5；
Step3.5、判断p＜newFaultdataList.get(i).size()，如果是执行Step3.6，否则i++，执行Step3.3；
Step3.6、判断newFaultdataList.get(i).get(p)＞60，如果是执行Step3.7，否则p++，q++，执行Step3.5；其中，newFaultdataList.get(i).get(p)表示二维列表newFaultdataList中第i条服务运行数据的第p个属性的值；
Step3.7、设置f＝p+1，执行Step3.8；
Step3.8、判断f＜newFaultdataList.get(i).size()-p，如果是执行Step3.9，否则将newFaultdataList.get(i)存入的二维列表newFaultList1，并标记类别为Faultq，i++，执行Step3.3；其中，newFaultdataList.get(i)表示二维列表newFaultdataList的第i条数据；
Step3.9、判断newFaultdataList.get(i).get(f)＜60：如果是执行Step3.10，否则执行Step3.11；
Step3.10、f++，执行Step3.8；
Step3.11、记录newFaultdataList.get(i).get(f)下标f赋给tag，执行Step3.12；
Step3.12、新建一个空的一维列表List，List.add(p)，List.add(tag)，执行Step3.13；其中，List.add(p)表示在列表List中添加p值，List.add(tag)表示在列表List中添加tag值；
Step3.13、判断tempList是否包含List列表中p和tag的值，如果是执行Step3.14，否则执行Step3.15；
Step3.14、将newFaultdataList.get(i)存入二维列表newFaultList1，获取到tempList中对应列表最后一列的值value，并标记类别为Faultvalue，i++，执行Step3.3；
Step3.15、设置q1++，执行Step3.16；
Step3.16、新建一个空的一维列表List1，List1.add(p)，List1.add(tag)，Listl.add(q1)，tempList.add(Listl)，执行Step3.18；其中，List1.add(p)表示在列表List1中添加p值，List1.add(tag)表示在列表List1中添加tag值，List1.add(q1)表示在列表List1中添加q1值，tempList.add(List1)表示把列表List1添加到列表tempList；
Step3.17、将newFaultdataList.get(i)存入的二维列表newFaultList1并标记类别为Faultq1，i++，执行Step3.3。
所述Step4具体如下：
Step4.1、设置j＝0，k＝1，执行Step4.2；
Step4.2、判断j＜n，如果是执行Step4.3，否则执行Step5；其中，n表示服务故障分类后的类别总数；
Step4.3、读取第j类服务故障的二维列表newFaultList1t*d，执行Step4.4；其中，t、d表示列表newFaultList1的行、列；
Step4.4、抽取第j类服务故障的若干服务故障特征Yk，执行Step4.5；其中，k＝1，2，3，...，m，m表示服务故障特征值总数；
Step4.5、判断k≤m，如果是执行Step4.6，否则执行Step4.7；
Step4.6、将j类的服务故障特征Yk存入服务故障特征列表featureList，k++，执行Step4.5；
Step4.7、j++，执行Step4.2。
所述Step5具体如下：
Step5.1、设置j＝1，x＝1，执行Step5.2；
Step5.2、判断j≤n，如果是执行Step5.3，否则结束执行；
Step5.3、读取j类别下的列表newFaultListlt*d，然后将列表中的类别标记属性列删除后存入列表newFaultListt*(d-1)，执行Step5.4；
Step5.4、判断x≤Bum：如果是执行Step5.5，否则执行Step5.24；其中，Bum表示已知服务故障类别总数；
Step5.5、读取x类别下的故障数据存入列表knownFaultListo*u，执行Step5.6；其中，o、u表示列表knownFaultList的行、列；
Step5.6、设置count＝0，e＝0，执行Step5.7；其中，count表示概率值大于1的总次数；
Step5.7、判断e＜newFaultList.size()，如果是执行Step5.8，否则执行Step5.11；其中，newFaultList.size()表示列表newFaultList的数据总条数大小；
Step5.8、j类别下的newFaultList.get(e)与x类别下的knownFaultListo*u采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
Figure BDA0002893219200000041
其中，newFaultList.get(e)表示列表newFaultList的第e条数据，j类别下二维列表newFaultListt*(d-1)为待分类项，服务故障二维列表newFaultListt*(d-1)的特征属性集为X＝{X1，X2，...，Xd-1}，d-1表示列表newFaultList有d-1个属性列，已知故障列表knownFaultList类别集合为Y＝{y1，y2，...，ynum}，P(Y|x)表示j类别下的特征属性集X属于Y类别的概率，P(Y)表示已知故障列表knownFaultList中各类别分别发生的概率，即先验概率，P(X|Y)表示特征属性集X下的各属性值在已知服务故障的每个类别Y中出现的概率，P(X)表示特征属性集X分别发生的概率；
Step5.9、判断newFaultList.get(e)概率值＞1，如果是执行Step5.10，否则e++，执行Step5.7；
Step5.10、count++，e++，执行Step5.7；
Step5.11、判断
Figure BDA0002893219200000042
如果是执行Step5.12，否则x++，执行Step5.4；
Step5.12、读取j类别对应的服务故障特征列表featureList，执行Step5.13；
Step5.13、设置k＝1，y＝1，y1＝0，执行Step5.14；其中，y1表示已知服务故障特征值对应的下标；
Step5.14、判断k≤featureList.size()-1，如果是执行Step5.15，否则x＝1，j++，执行Step5.2；其中，featureList.size()表示列表featureList的数据个数的大小；
Step5.15、读取x对应的故障特征列表存入knownFeatureList，执行Step5.16；
Step5.16、判断y≤knownFeatureList.size()-1，如果是则执行Step5.17，否则执行Step5.20；其中，knownFeatureList.size()表示列表knownFeatureList的数据个数的大小；
Step5.17、判断featureList.get(k).equals(knownFeatureList.get(y))，如果是执行Step5.18，否则执行Step5.19；其中，featureList.get(k).equals(knownFeatureList.get(y))表示列表featureList中第k个数据的值等于列表knownFeatureList中第v个数据的值；
Step5.18、y1＝0，y＝1，k++，执行Step5.14；
Step5.19、v++，执行Step5.16；
Step5.20、读取已知服务故障的所有故障特征值存入列表totalList，执行Step5.21；
Step5.21、判断y1＜totalList.size()，如果是执行Step5.22，否则执行Step5.23；其中，totalList.size()表示列表totalList的数据个数的大小；
Step5.22、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.18，否则y1++，执行Step5.21；其中，featureList.get(k).equals(totalList.get(y1))表示列表featureList中第k个数据的值等于列表totalList中第y1个数据的值；
Step5.23、将featureList.get(k)作为新故障特征添加在已知故障x类别下，执行Step5.18；
Step5.24、将j类别下的newFaultListt*(d-1)存入x类的knownFaultListo*u，执行Step5.25；
Step5.25、读取j类别对应的服务故障特征列表featureList，执行Step5.26；
Step5.26、k＝1，y1＝0，执行Step5.27；
Step5.27、读取已知服务故障的所有服务故障特征存入列表totalList，执行Step5.28；
Step5.28、判断k≤featureList，size()-1，如果是执行Step5.29，否则x＝1，j++，执行Step5.2；
Step5.29、判断y1＜totalList.size()，如果是执行Step5.30，否则执行Step5.33；
Step5.30、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.31，否则执行Step5.32；
Step5.31、y1＝0，k++，执行Step5.28；
Step5.32、y1++，执行Step5.29；
Step5.33、将featureList.get(k)作为新故障特征添加在j类别下，执行Step5.31。
本发明的有益效果是：
(1)本发明能动态识别出云计算环境下服务故障与服务故障特征。
(2)本发明能通过分析服务故障与服务故障特征间的关联性，建立服务故障与服务故障特征的网状结构，实现服务故障模型的动态演化。
附图说明
图1是本发明的总流程图；
图2为图1中步骤Step1的具体流程；
图3为图1中步骤Step2的具体流程；
图4为图1中步骤Step3的具体流程；
图5为图1中步骤Step4的具体流程；
图6为图1中步骤Step5的具体流程；
图7为已知服务故障与已知服务故障特征关联网状图；
图8为动态更新服务故障与服务故障特征关联网状图。
具体实施方式
实施例1：如图1-图8所示，一种云计算环境下服务故障模型动态建立方法，所述方法在执行过程中，首先，按照Step1-Step2-Step3-Step4-Step5的流程一次遍历；然后，按照Step2-Step3-Step4-Step5的流程依次遍历直至终止执行。
所述方法具体步骤如下：
Step1、预处理服务运行数据：对服务运行数据集进行方差计算，根据方差计算结果删除运行数据集中无效的属性数据列，获得预处理服务运行数据集列表，减少计算的复杂度；
Step2、抽取服务故障：对预处理服务运行数据集列表进行服务故障判断，抽取服务故障数据；
Step3、确定服务故障分类：对抽取出的服务故障数据通过多属性的不同表现形式产生不同服务故障的分类方式，对服务故障数据进行分类，并对分类后的服务故障数据进行类别标记；
Step4、抽取服务故障特征：对分类后的服务故障分别抽取服务故障特征，抽取出的服务故障特征代表该类故障发生时所产生的故障表现形式；
Step5、动态关联服务故障与服务故障特征：对分类后的服务故障与已知服务故障进行朴素贝叶斯概率计算，识别出新产生的服务故障；对服务故障中抽取的服务故障特征与已知服务故障特征进行比对，识别出新产生的服务故障特征；分析服务故障与服务故障特征间关联并动态更新已知服务故障与已知服务故障特征间关联。
服务运行数据属性表如表1所示，表中给出了服务运行数据属性的含义和服务运行数据的类别标注。
表1服务运行数据属性表
Figure BDA0002893219200000061
进一步地，可以设置所述方法具体步骤如下(如下主要以CPU服务运行数据进行实验说明)：
Step1.1预处理服务运行数据；初始化云计算环境下监测到的服务运行数据集D，从服务运行数据集D中提取出服务运行数据存入服务运行数据列表ServiceDataList，ServiceDataListr*c＝[[J1],[J2],[J3],...,[Jr]]，[J1]＝[M1,M2,M3,...,Mc]，其中J1为第1条服务运行数据，Jr为第r条服务运行数据，Mc为第1条服务运行数据的第c个属性，r为服务运行数据列表中数据总条数，c为每条服务运行数据属性的总数，服务运行数据总条数r＝30，每条服务运行数据属性的总数c＝5，服务运行数据表如表2所示，设置临时变量g＝0，临时变量h＝0，执行Step1.2；
表2服务运行数据表
cpu_user cpu_sys cpu_wait cpu_irq cpu_softirq
82.0 4.5 2.0 0.0 98.0
7.7 1.8 0.0 0.0 0.2
2.4 1.9 0.0 0.0 0.0
1.3 1.6 0.0 0.0 0.0
5.3 94.4 0.0 0.0 0.2
2.2 1.5 0.0 0.0 0.0
34.2 5.0 0.7 0.0 0.0
0.9 1.1 0.0 0.0 0.0
35.7 3.0 71.8 0.0 0.0
71.7 1.5 0.0 0.0 0.0
35.6 3.1 76.9 0.0 0.0
14.8 75.4 0.7 0.0 0.0
5.5 93.3 0.0 0.0 0.0
6.5 89.1 0.5 0.0 0.0
35.0 2.8 77.5 0.0 0.0
84.2 1.3 0.0 0.0 0.0
84.0 0.9 0.0 0.0 0.0
84.6 0.9 0.0 0.0 0.0
97.9 2.1 0.0 0.0 0.0
98.2 1.8 0.0 0.0 0.0
35.8 2.9 79.8 0.0 0.0
34.4 26.1 0.2 0.0 0.0
35.8 3.0 78.3 0.0 0.2
34.1 80.7 0.2 0.0 0.0
15.5 79.5 0.2 0.0 0.0
72.3 3.8 8.2 0.0 84.6
71.5 1.3 2.6 0.0 98.3
72.6 21.8 0.2 0.0 98.3
80.7 6.7 1.8 0.0 98.1
34.1 1.1 2.2 0.0 0.2
Step1.2、判断g＜ServiceDataList.get(h).size()：0<5，执行Step1.3；
循环执行Step1.2至Step1.12，当g＝5时，结束执行本步骤，接着执行下一个步骤；
Step1.3、初始化一个空列表resultList，此列表用来存放属性列的服务运行数据，执行Step1.4；
Step1.4、判断h＜ServiceDataList.size()：0＜30，执行Step1.5；
Step1.5、将ServiceDataList.get(h).get(g)存入到resultList列表，h++，执行Step1.4；
将ServiceDataList.get(0).get(0)存入到resultList列表，h＝1，执行Step1.4；
循环执行Step1.4、Step1.5，得到resultList列表，当h＝30时，执行Step1.6；
resultList＝[82.0，7.7，2.4，2.4，1.3，5.3，2.2，34.2，0.9，35.7，71.7，35.6，14.8，5.5，6.5，35.0，84.2，84.0，84.6，97.9，98.2，35.8，34.4，35.8，34.1，15.5，72.3，71.5，72.6，80.7，34.1]；
Step1.6、设置临时变量a＝0，属性列数据总和sum＝0，属性列数据平均值average＝0，属性列数据方差variance＝0，临时变量v＝0，判断a＜resultList.size()：0＜30，执行Step1.7；
Step1.7、计算数据总和sum+＝resultList.get(a)，a++，执行Step1.6；
数据总和：sum＝resultList.get(0)＝82，a＝1，执行Step1.6；
循环执行Step1.6、Step1.7，得到resultList的数据总和为：
sum＝82.0+7.7+2.4+1.3+5.3+2.2+...+34.1＝1276.50
当a＝30时，执行Step1.8；
Step1.8、计算数据平均值
Figure BDA0002893219200000081
执行Step1.9；
平均值为：
Figure BDA0002893219200000082
Step1.9、设置临时变量b＝0，执行Step1.10；
Step1.10、判断b＜resultList.size()：0＜30，执行Step1.11；
Step1.11、v+＝(resultList.get(b)-average)2，b++，执行Step1.9；
v＝(resultList.get(0)一average)2＝1556.3025
循环执行Step1.10、Step1.11，得到方差公式中分子部分的结果：
v＝(82.0-31.86)2+(7.7-31.86)2+...+(34.1-31.86)2＝31844.08
当b＝30时，执行Step1.12；
Step1.12、计算方差值
Figure BDA0002893219200000083
判断variance＞0，如果是保留属性列resultList，否则删除该属性列resultList，g++，执行Step1.2；
执行Step1.12，得到属性cpu_user的方差值为：
Figure BDA0002893219200000084
判断1061.47＞0，保留属性列的服务运行数据cpu_user；
通过循环执行Step1.2至Step1.12，分别得到5个属性的方差结果：
cpu_user＝1061.47
cpu_sys＝1094.81
cpu-wait＝807.55
cpu_irq＝0.0
cpu-softirq＝1269.71；
判断方差结果variance＝0的属性列cpu_irq被删除，剩余cpu_user、cpu_syscpu_wait、cpu_softirq四个属性保留，预处理服务运行数据集列表如表3所示。
表3预处理服务运行数据集列表
cpu_user cpu_sys cpu_wait cpu_softirq
82.0 4.5 2.0 98.0
7.7 1.8 0.0 0.2
2.4 1.9 0.0 0.0
1.3 1.6 0.0 0.0
5.3 94.4 0.0 0.2
2.2 1.5 0.0 0.0
34.2 5.0 0.7 0.0
0.9 1.1 0.0 0.0
35.7 3.0 71.8 0.0
71.7 1.5 0.0 0.0
35.6 3.1 76.9 0.0
14.8 75.4 0.7 0.0
5.5 93.3 0.0 0.0
6.5 89.1 0.5 0.0
35.0 2.8 77.5 0.0
84.2 1.3 0.0 0.0
84.0 0.9 0.0 0.0
84.6 0.9 0.0 0.0
97.9 2.1 0.0 0.0
98.2 1.8 0.0 0.0
35.8 2.9 79.8 0.0
34.4 26.1 0.2 0.0
35.8 3.0 78.3 0.2
34.1 80.7 0.2 0.0
15.5 79.5 0.2 0.0
72.3 3.8 8.2 84.6
71.5 1.3 2.6 98.3
72.6 21.8 0.2 98.3
80.7 6.7 1.8 98.1
34.1 1.1 2.2 0.2
所述Step2具体如下：
Step2.1、设置临时变量s＝0，执行Step2.2；
Step2.2、读取预处理服务运行数据集存入二维列表dataList，执行Step2.3；
dataList30*4＝[[82.0，4.5，2.0，98.0]，[7.7，1.8，0.0，0.2]，[2.4，1.9，0.0，0.0]，[1.3，1.6，0.0，0.0]，[5.3，94.4，0.0，0.2]，[2.2，1.5，0.0，0.2]，[34.2，5.0，0.7，0.0]，[0.9，1.1，0.0，0.0]，[35.7，3.0，71.8，0.0]，[71.7，1.5，0.0，0.0]，[35.6，3.1，76.9，0.0]，[14.8，75.4，0.7，0.0]，[5.5，93.3，0.0，0.0]，[6.5，89.1，0.5，0.0]，[35.0，2.8，77.5，0.0]，[84.2，1.3，0.0，0.0]，[84.0，0.9，0.0，0.0]，[84.6，0.9，0.0，0.0]，[97.9，2.1，0.0，0.0]，[98.2，1.8，0.0，0.0]，[35.8，2.9，79.8，0.0]，[34.4，26.1，0.2，0.0]，[35.8，3.0，78.3，0.2]，[34.1，80.7，0.2，0.0]，[15.5，79.5，0.2，0.0]，[72.3，3.8，8.2，84.6]，[71.5，1.3，2.6，98.3]，[72.6，21.8，0.2，98.3]，[80.7，6.7，1.8，98.1]，[34.1，1.1，2.2，0.2]]；
Step2.3、判断s＜dataList.size()：0＜30，执行Step2.4；
当s＝30时，结束执行本步骤，接着执行下一个步骤；
Step2.4、设置临时变量w＝0，执行Step2.5；
Step2.5、判断w＜dataList.get(s).size()：0＜4，执行Step2.6；
Step2.6、判断dataList.get(s).get(w)＞60，如果是执行Step2.8；否则执行Step2.9；
对第1条数据进行判断：
当s＝0，w＝0时，
判断dataList.get(0).get(0)＞60，由于82.0＞60，执行Step2.8；
循环执行Step2.3-Step2.6，对第2条数据进行判断：
当s＝1，w＝0时，判断dataList.get(1).get(0)＞60，由于7.7＜60，执行Step2.9；
当s＝1，w＝1时，判断dataList.get(1).get(1)＞60，由于1.8＜60，执行Step2.9；
当s＝1，w＝2时，判断dataList.get(1).get(2)＞60，由于0.0＜60，执行Step2.9；
当s＝1，w＝3时，判断dataList.get(1).get(3)＞60，由于0.2＜60，执行Step2.9；
当s＝1，w＝4，执行Step2.7；
Step2.7、dataList.get(s)为正常数据，s++，执行Step2.3；
当w＝4时，dataList.get(1)里面所有属性列数据都小于60，判断dataList.get(1)为正常数据，s＝2，执行Step2.3
Step2.8、将dataList.get(s)存入二维列表newFaultdataList，s++，执行Step2.3；
82.0＞60，将dataList.get(0)＝[82.0，4.5，2.0，98.0]存入newFaultdataList中，s＝1，执行Step2.3；
Step2.9、w++，执行Step2.5；
通过循环执行Step2.3至Step2.9，最终得到了一个故障数据二维列表newFaultdataList如下：
newFaultdataList22*4＝[[82.0，4.5，2.0，98.0]，[5.3，94.4，0.0，0.2]，[35.7，3.0，71.8，0.0]，[71.7，1.5，0.0，0.0]，[35.6，3.1，76.9，0.0]，[14.8，75.4，0.7，0.0]，[5.5，93.3，0.0，0.0]，[6.5，89.1，0.5，0.0]，[35.0，2.8，77.5，0.0]，[84.2，1.3，0.0，0.0]，[84.0，0.9，0.0，0.0]，[84.6，0.9，0.0，0.0]，[97.9，2.1，0.0，0.0]，[98.2，1.8，0.0，0.0]，[35.8，2.9，79.8，0.0]，[35.8，3.0，78.3，0.0]，[34.1，80.7，0.2，0.0]，[15.5，79.5，0.2，0.0]，[72.3，3.8，8.2，84.6]，[71.5，1.3，2.6，98.3]，[72.6，21.8，0.2，98.3]，[80.7，6.7，1.8，98.1]]；
所述Step3具体如下：
Step3.1、设置临时变量i＝0，tag＝0，q1＝newFaultdataList.get(i).size()＝4，新建二维列表tempList，执行Step3.2；其中，tag用于存储数据对应的下标，q1用于存储newFaultdataList中第i条服务运行数据属性个数的大小，newFaultdataList.get(i).size()表示二维列表newFaultdataList中第i条服务运行数据属性个数的大小，即二维列表newfaultdatalist里第i个一维列表属性个数的大小；
Step3.2、读取服务故障数据集二维列表newFaultdataList22*4，执行Step3.3；
Step3.3、判断i＜newFaultdataList.size()：0＜22，执行Step3.4，否则结束执行本步骤，接着执行下一个步骤；
Step3.4、设置临时变量p＝0，临时变量q＝1，执行Step3.5；
Step3.5、判断p＜newFaultdataList.get(i).size()：0＜4，执行Step3.6，否则i++，执行Step3.3；
Step3.6、判断newFaultdataList.get(i).get(p)＞60，如果是执行Step3.7，否则p++，q++，执行Step3.5；
对第1条数据进行判断：判断newFaultdataList.get(0).get(0)＝82＞60，执行Step3.7；
如下介绍了其它的循环数据：
循环执行Step3.3至Step3.6，对第2条数据进行判断：
当i＝1，p＝0时，判断newFaultdataList.get(1).get(0)＞60，5.3＜60，p＝1，q＝2，执行Step3.5；
当i＝1，p＝1时，判断newFaultdataList.get(1).get(1)＞60，94.4＞60，执行Step3.7；
循环执行Step3.3至Step3.6，对第19条数据进行判断：
当i＝18，p＝0时，判断newFaultdataList.get(18).get(0)＞60，72.3＞60，执行Step3.7；
Step3.7、设置f＝p+1，执行Step3.8；f＝1，执行Step3.8；其中，f用于存储newFaultdataList列表中大于60的值所对应的下标；
如下介绍了其它的循环数据：
由于newFaultdataList.get(1).get(1)＞60，对应f＝2，执行Step3.8；
由于newFaultdataList.get(18).get(0)＞60，对应f＝1，执行Step3.8；
Step3.8、判断f＜newFaultdataList.get(i).size()-p：f＜4，如果是执行Step3.9，否则将newFaultdataList.get(i)存入的二维列表newFaultList1，并标记类别为Faultq，i++，执行Step3.3；
第1次循环，判断f＝1＜4，执行Step3.9；
如下介绍了其它的循环数据：
第2次循环，判断f＝2＜4，执行Step3.9；
第3次循环，判断f＝1＜4，执行Step3.9；
Step3.9、判断newFaultdataList.get(i).get(f)＜60，如果是执行Step3.10，否则执行Step3.11；
第1次循环，判断newFaultdataList.get(0).get(1)＝4.5＜60，执行Step3.10；
如下介绍了其它的循环数据：
第2次循环，判断newFaultdataList.get(1).get(2)＝0.0＜60，执行Step3.10；
第3次循环，判断newFaultdataList.get(18).get(1)＝3.8＜60，执行Step3.10；
Step3.10、f++，执行Step3.8；
第1次循环，f＝2，执行Step3.8；
第2次循环，f＝3，执行Step3.8；
第3次循环，f＝2，执行Step3.8；
循环执行Step3.8、Step3.9、Step3.10，对第1条数据判断：
当i＝0，f＝1，1＜4时，判断newFaultdataList.get(0).get(1)＜60，4.5＜60，执行Step3.10，f＝2；
当i＝0，f＝2，2＜4时，判断newFaultdataList.get(0).get(2)＜60，2.0＜60，执行Step3.10，f＝3；
当i＝0，f＝3，3＜4时，判断newFaultdataList.get(0).get(3)＜60，98.0＞60，执行Step3.11；
如下介绍了其它的循环数据：
循环执行Step3.8、Step3.9、Step3.10，对第2条数据判断：
当i＝1，f＝2，2＜4时，判断newFaultdataList.get(1).get(2)＜60，0.0＜60，执行Step3.10；
当i＝1，f＝3，3＜4时，判断newFaultdataList.get(1).get(3)＜60，0.2＜60，执行Step3.10；
当i＝1，f＝4，4＝4时，将newFaultdataList.get(1)存入的二维列表newFaultList1，并标记类别为Fault2，i＝2，执行Step3.3；
循环执行Step3.8、Step3.9、Step3.10，对第19条数据判断：
当i＝18，f＝1，1＜4时，判断newFaultdataList.get(0).get(1)＜60，3.8＜60，执行Step3.10，f＝2；
当i＝18，f＝2，2＜4时，判断newFaultdataList.get(0).get(2)＜60，8.2＜60，执行Step3.10，f＝3；
当i＝18，f＝3，3＜4时，判断newFaultdataList.get(0).get(3)＜60，84.6＞60，执行Step3.11；
Step3.11、记录newFaultdataList.get(i).get(f)下标f赋给tag，执行Step3.12；
第1条数据，记录newFaultdataList.get(0).get(3)下标，tag＝3，执行Step3.12；
第19条数据，记录newFaultdataList.get(18).get(3)下标，tag＝3，执行Step3.12；
Step3.12、新建一个空的一维列表List，List.add(p)，List.add(tag)，执行Step3.13；
对应第1条数据：空列表List中添加了p＝0，tag＝3，List＝[0，3]，执行Step3.13；
对应第19条数据：空列表List中添加了p＝0，tag＝3，List＝[0，3]，执行Step3.13；
Step3.13、判断tempList是否包含List列表中p和tag的值，如果是执行Step3.14，否则执行Step3.15；
对应第1条数据：判断tempList中不包含List列表中p＝0，tag＝3，执行Step3.15；
对应第19条数据：判断tempList中包含List列表中p＝0，tag＝3，执行Step3.14；
Step3.14、将newFaultdataList.get(i)存入的二维列表newFaultList1，获取到tempList中对应列表最后一列的值value，并标记类别为Faultvalue，i++，执行Step3.3；其中，Faultvalue表示类别标记；
将newFaultdataList.get(18)存入二维列表newFaultList1，获取到tempList＝[[0，3，5]]中对应列表[0，3，5]最后一列的值value＝5，标记类别为Fault5，i＝19，执行Step3.3；
Step3.15、设置q1++，执行Step3.16；
q1＝5，执行Step3.16；
Step3.16、新建一个空的一维列表List1，Listl.add(p)，Listl.add(tag)，List1.add(q1)，tempList.add(List1)，执行Step3.17；
新建空列表List1中添加p＝0、tag＝3、q1＝5，List1＝[0，3，5]，将List1列表添加到二维列表tempList中，tempList＝[[0，3，5]]，执行Step3.17；
Step3.17、将newFaultdataList.get(i)存入的二维列表newFaultList1并标记类别为Faultq1，i++，执行Step3.3；其中，Faultq1表示类别标记；
将newFaultdataList.get(0)存入二维列表newFaultList1，类别标记为Fault5，i＝1，执行Step3.3；通过循环执行Step3.3至Step3.17，得到服务故障分类后的故障二维列表newFaultList122*5如下：
newFaultList122*5＝[[82.0，4.5，2.0，98.0，Fault5]，[5.3，94.4，0.0，0.2，Fault2]，[35.7，3.0，71.8，0.0，Fault3]，[71.7，1.5，0.0，0.0，Fault1]，[35.6，3.1，76.9，0.0，Fault3]，[14.8，75.4，0.7，0.0，Fault2]，[5.5，93.3，0.0，0.0，Fault2]，[6.5，89.1，0.5，0.0，Fault2]，[35.0，2.8，77.5，0.0，Fault3]，[84.2，1.3，0.0，0.0，Fault1]，[84.0，0.9，0.0，0.0，Fault1]，[84.6，0.9，0.0，0.0，Fault1]，[97.9，2.1，0.0，0.0，Fault1]，[98.2，1.8，0.0，0.0，Fault1]，[35.8，2.9，79.8，0.0，Fault3]，[35.8，3.0，78.3，0.0，Fault3]，[34.1，80.7，0.2，0.0，Fault2]，[15.5，79.5，0.2，0.0，Fault2]，[72.3，3.8，8.2，84.6，Fault5]，[71.5，1.3，2.6，98.3，Fault5]，[72.6，21.8，0.2，98.3，Fault5]，[80.7，6.7，1.8，98.1，Fault5]]；
所述Step4具体如下：
Step4.1、设置j＝0，k＝1，执行Step4.2；其中，j表示服务故障类别对应的下标，k表示服务故障特征值对应的下标；
Step4.2、判断j＜n(服务故障分类后的类别总数)：j＜4，如果是执行Step4.3，否则结束本步骤，执行下一个步骤；
判断j＝0，j＜4，执行Step4.3；
Step4.3、读取第j类服务故障二维列表newFaultList1t*d，执行Step4.4；
读取Fault1类服务故障二维列表newFaultList16*5，执行Step4.4；
newFaultList16*5＝[[84.2，1.3，0.0，0.0，Fault1]，[71.7，1.5，0.0，0.0，Fault1]，[84.0，0.9，0.0，0.0，Fault1]，[84.6，0.9，0.0，0.0，Fault1]，[97.9，2.1，0.0，0.0，Fault1]，[98.2，1.8，0.0，0.0，Fault1]]；
Step4.4、抽取第j类服务故障的若干服务故障特征Yk(k＝1，2，3，...，m)，执行Step4.5；
抽取Fault1类服务故障的特征为Y1＝A，Y2＝B，Y3＝C，Y4＝D，Y5＝E，执行Step4.5；A、B、C、D、E为服务故障发生时表现的具体特征形式；
Step4.5、判断k≤m(服务故障特征值总数)，如果是执行Step4.6，否则执行Step4.7；
判断1≤5，执行Step4.6；
Step4.6、将j类的服务故障特征Yk存入服务故障特征列表featureList，k++，执行Step4.5；
将Fault1类的服务故障特征Y1＝A存入服务故障特征列表featureList，k＝2，执行Step4.5；
循环执行Step4.5、Step4.6，得到Fault1类的服务故障特征列表featureList如下：
featureList＝[Fault1，A，B，C，D，E]；
Step4.7、j++，执行Step4.2；
j＝2，执行Step4.2，直至不满足j＜n。
所述Step5具体如下：
Step5.1、设置户1，x＝1，执行Step5.2；其中，x表示已知服务故障类别对应的下标；
Step5.2、判断j≤n(服务故障类别总数)：j≤4，如果是执行Step5.3，否则结束执行；
判断1＜4，执行Step5.3；
如下介绍了其它的循环数据：
判断2＜4，执行Step5.3；
判断3＜4，执行Step5.3；
Step5.3、读取j类别下的列表newFaultListlt*d，然后将列表中的类别标记属性列删除后存入列表newFaultListt*(d-1)，执行Step5.4；
读取Fault1类别下的列表newFaultList6*4如下，执行Step5.4；
newFaultList6*4＝[[84.2，1.3，0.0，0.0]，[71.7，1.5，0.0，0.0]，[84.0，0.9，0.0，0.0]，[84.6，0.9，0.0，0.0]，[97.9，2.1，0.0，0.0]，[98.2，1.8，0.0，0.0]]；
读取Fault2类别下的列表newFaultList6*4如下，执行Step5.4；
newFaultList6*4＝[[5.3，94.4，0.0，0.2]，[14.8，75.4，0.7，0.0]，[5.5，93.3，0.0，0.0]，[6.5，89.1，0.5，0.0]，[34.1，80.7，0.2，0.0]，[15.5，79.5，0.2，0.0]]；
读取Fault3类别下的列表newFaultList5*4如下，执行Step5.4；
newFaultLists*4＝[[35.7，3.0，71.8，0.0]，[35.6，3.1，76.9，0.0]，[35.0，2.8，77.5，0.0]，[35.8，2.9，79.8，0.0]，[35.8，3.0，78.3，0.0]]；
Step5.4、判断x≤Bum(已知服务故障类别总数)，如果是执行Step5.5，否则执行Step5.24；
执行第1次循环，当x＝1，判断1≤2，执行Step5.5；
执行第2次循环，当x＝1，判断1≤2，执行Step5.5；当x＝2，判断2＝2，执行Step5.5；
执行第3次循环，当x＝1，判断1≤2，执行Step5.5；当x＝2，判断2＝2，执行Step5.5；当x＝3，判断3＞2，执行Step5.24；
Step5.5、读取x类别下的故障数据存入列表knownFaultListo*u，执行Step5.6；
读取fault1类别下的故障数据存入列表knownFaultList16*4如下，执行Step5.6；fault1不同于Fault1；
knownFaultList16*4＝[[84.8，0.6，0.0，0.0]，[98.3，1.7，0.0，0.0]，[98.1，1.9，0.0，0.0，]，[98.4，1.6，0.0，0.0]，[72.0，2.2，0.0，0.0]，[72.2，1.9，0.0，0.0]，[71.8，2.0，0.0，0.0]，[72.3，1.8，0.0，0.0]，[72.9，1.8，0.0，0.0]，[80.7，8.4，0.9，0.2]，[85.3，1.7，0.4，0.0]，[92.4，2.9，4.3，0.0]，[74.1，25.2，0.3，0.0]，[96.38，4.0，7.7，0.2]，[96.39，4.0，7.7，0.2]，[96.39，4.1，7.9，0.0]]；
读取fault2类别下的故障数据存入列表knownFaultList14*4如下，执行Step5.6；
knownFaultList14*4＝[[15.1，75.5，0.2，0.2]，[14.8，75.4，0.7，0.0]，[15.5，74.4，0.7，0.0]，[15.1，75.1，0.2，0.0]，[15.2，78.2，0.2，0.0]，[14.7，71.2，0.9，0.9]，[6.5，88.4，1.6，0.0]，[6.5，86.1，0.5，0.0]，[6.4，85.2，2.6，0.0]，[5.1，94.9，0.0，0.0]，[5.5,93.3,0.0,0.0],[5.3,94.4,0.0,0.2],[5.4,98.6,0.0,0.2][13.7,86.2,0.0,0.0]]；
Step5.6、设置临时变量count＝0，临时变量e＝0，执行Step5.7；
Step5.7、判断e＜newFaultList.size()，如果是执行Step5.8，否则执行Step5.11；
执行第1次循环，Fault1与fault1：当e＝0，判断0<6，执行Step5.8；
执行第2次循环，Fault2与fault1：当e＝0，判断0<6，执行Step5.8；当e＝1，判断1<6，执行Step5.8；当e＝2，判断2<6，执行Step5.8；
Fault2与fault2：当e＝0，判断0<6，执行Step5.8；当e＝1，判断1<6，执行Step5.8；
执行第3次循环，Fault3与fault1：当e＝0，判断0<5，执行Step5.8；
Fault3与fault2：当e＝0，判断0<5，执行Step5.8；
Step5.8、j类别下的newFaultList.get(e)与x类别下的knownFaultListo*u采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
Figure BDA0002893219200000151
执行第1次循环，Fault1与fault1，当e＝0时，Fault1类别下的newFaultList.get(0)＝[84.2,1.3,0.0,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault1|newFaultList.get(0))＝1.139323
执行第2次循环，Fault2与fault1，当e＝0时，Fault2类别下的newFaultList.get(0)＝[5.3,94.4,0.0,0.2]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault1|newFaultList.get(0))＝0.325521
当e＝1时，Fault2类别下的newFaultList.get(1)＝[14.8,75.4,0.7,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault1|newFaultList.get(1))＝0.113932
当e＝2时，Fault2类别下的newFaultList.get(2)＝[5.5,93.3,0.0,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault1|newFaultList.get(2))＝1.139323
Fault2与fault2，当e＝0时，Fault2类别下的newFaultList.get(0)＝[5.3,94.4,0.0,0.2]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault2|newFaultList.get(0))＝1.157407
执行第3次循环，Fault3与fault1，当e＝0时，Fault3类别下的newFaultList.get(0)＝[35.7,3.0,71.8,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault1|newFaultList.get(0))＝0.113932
Fault3与fault2，当e＝0时，Fault3类别下的newFaultList.get(0)＝[35.7,3.0,71.8,0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
P(fault2|newFaultList.get(0))＝0.212191
Step5.9、判断newFaultList.get(e)概率值>1，如果是执行Step5.10，否则e++，执行Step5.7；
执行第1次循环，Fault1与fault1
判断newFaultList.get(0)的概率1.139323＞1，执行Step5.10；
执行第2次循环，Fault2与fault1
判断newFaultList.get(0)的概率0.325521＜1，e＝1，执行Step5.7；
判断newFaultList.get(1)的概率0.113932＜1，e＝2，执行Step5.7；
判断newFaultList.get(2)的概率1.139323＞1，执行Step5.10；
Fault2与fault2
判断newFaultList.get(0)的概率1.157407＞1，执行Step5.10；
执行第3次循环，Fault3与fault1
判断newFaultList.get(0)的概率0.113932＜1，e＝1，执行Step5.7；
通过第3次循环执行Step5.6至Step5.9得到Fault3与fault1采用公式(1)计算朴素贝叶斯概率后得结果如下：
当e＝0时，Fault3类别下的newFaultList.get(0)＝[35.7,3.0,71.8,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(0))＝0.113932
当e＝1时，Fault3类别下的newFaultList.get(1)＝[35.6,3.1,76.9,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(1))＝0.113932
当e＝2时，Fault3类别下的newFaultList.get(2)＝[35.0,2.8,77.5,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(2))＝0.113932
当e＝3时，Fault3类别下的newFaultList.get(3)＝[35.8,2.9,79.8,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(3))＝0.227865
当e＝4时，Fault3类别下的newFaultList.get(4)＝[35.8,3.0,78.3,0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(4))＝0.032552
通过循环执行Step5.6至Step5.9，count＝0，执行Step5.11；
Fault3与fault2
判断newFaultList.get(0)的概率0.113932＜1，e＝1，执行Step5.7；
通过第3次循环执行Step5.6至Step5.10得到Fault3与fault2采用公式(1)计算朴素贝叶斯概率后得结果如下：
Fault3类别下的newFaultList.get(0)＝[35.7,3.0,71.8,0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(0))＝0.113932
当e＝1时，Fault3类别下的newFaultList.get(1)＝[35.6,3.1,76.9,0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(1))＝0.113932
当e＝2时，Fault3类别下的newFaultList.get(2)＝[35.0，2.8，77.5，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(2))＝0.113932
当e＝3时，Fault3类别下的newFaultList.get(3)＝[35.8，2.9，79.8，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(3))＝0.227865
当e＝4时，Fault3类别下的newFaultList.get(4)＝[35.8，3.0，78.3，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(4))＝0.032552
通过循环执行Step5.6至Step5.9，count＝0，执行Step5.11；
Step5.10、count++，e++，执行Step5.7；
执行第1次循环，count＝1，e＝1，执行Step5.7；
通过第1次循环执行Step5.6至Step5.10得到Fault1与fault1采用公式(1)计算朴素贝叶斯概率后得结果如下：
当e＝0时，Fault1类别下的newFaultList.get(0)＝[84.2，1.3，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(0))＝1.139323
当e＝l时，Fault1类别下的newFaultList.get(1)＝[71.7，1.5，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(1))＝1.139323
当e＝2时，Fault1类别下的newFaultList.get(2)＝[84.0，0.9，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(2))＝1.060957
当e＝3时，Fault1类别下的newFaultList.get(3)＝[84.6，0.9，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(3))＝1.139323
当e＝4时，Fault1类别下的newFaultList.get(4)＝[97.9，2.1，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(4))＝1.139323
当e＝5时，Fault1类别下的newFaultList.get(5)＝[98.2，1.8，0.0，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(5))＝3.417969
通过循环执行Step5.6至Step5.10，count＝6，执行Step5.11；
执行第2次循环，count＝1，e＝3，执行Step5.7；
通过第2次循环执行Step5.6至Step5.10得到Fault2与fault1采用公式(1)计算朴素贝叶斯概率后得结果如下：
当e＝0时，Fault2类别下的newFaultList.get(0)＝[5.3，94.4，0.0，0.2]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(0))＝0.325521
当e＝1时，Fault2类别下的newFaultList.get(1)＝[14.8，75.4，0.7，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(1))＝0.113932
当e＝2时，Fault2类别下的newFaultList.get(2)＝[5.5，93.3，0.0，0.0]与faultl类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(2))＝1.139323
当e＝3时，Fault2类别下的newFaultList.get(3)＝[6.5，89.1，0.5，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(3))＝0.113932
当e＝4时，Fault2类别下的newFaultList.get(4)＝[34.1，80.7，0.2，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(4))＝0.113932
当e＝5时，Fault2类别下的newFaultList.get(5)＝[15.5，79.5，0.2，0.0]与fault1类别下的knownFaultList16*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault1|newFaultList.get(5))＝0.113932
通过循环执行Step5.6至Step5.10，count＝1，执行Step5.11；
执行第2次循环，count＝1，e＝1，执行Step5.7；
通过第2次循环执行Step5.6至Step5.10得到Fault2与fault2采用公式(1)计算朴素贝叶斯概率后得结果如下：
当e＝0时，Fault2类别下的newFaultList.get(0)＝[5.3，94.4，0.0，0.2]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(0))＝1.157407
当e＝1时，Fault2类别下的newFaultList.get(1)＝[14.8，75.4，0.7，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(1))＝2.546296
当e＝2时，Fault2类别下的newFaultList.get(2)＝[5.5，93.3，0.0，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(2))＝4.243827
当e＝3时，Fault2类别下的newFaultList.get(3)＝[6.5，89.1，0.5，0.0]与fault2类别下的knownFaultList14，4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(3))＝1.273148
当e＝4时，Fault2类别下的newFaultList.get(4)＝[34.1，80.7，0.2，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(4))＝0.636574
当e＝5时，Fault2类别下的newFaultList.get(5)＝[15.5，79.5，0.2，0.0]与fault2类别下的knownFaultList14*4采用公式(1)进行朴素贝叶斯概率计算，得到概率为：
P(fault2|newFaultList.get(5))＝1.273148
通过循环执行Step5.6至Step5.10，count＝5，执行Step5.11；
Step5.11、判断
Figure BDA0002893219200000191
如果是执行Step5.12，否则x++，执行Step5.4；
执行第1次循环，count＝6，判断6/6＝1＞0.8，执行Step5.12；
执行第2次循环，count＝1，判断1/6＝0.167＜0.8，x＝2，执行Step5.4；
判断count＝5，5/6＝0.833＞0.8，执行Step5.12；
执行第3次循环，count＝0，判断0/6＝0＜0.8，x＝2，执行Step5.4；
判断count＝0，0/6＝0＜0.8，x＝3，执行Step5.4；
Step5.12、读取j类别对应的服务故障特征列表featureList，执行Step5.13；
读取Fault1类别对应的服务故障特征列表featureList＝[Fault1，A，B，C，D，E]，执行Step5.13；
读取Fault2类别对应的服务故障特征列表featureList＝[Fault2，A，B，C，D，F]，执行Step5.13；
Step5.13、设置k＝1，临时变量y＝1，临时变量y1＝0，执行Step5.14；
Step5.14、判断k≤featureList.size()-1，如果是执行Step5.15，否则x＝1，j++，执行Step5.2；
执行第1次循环，k≤5，
判断1＜5，执行Step5.15；判断2＜5，执行Step5.15；判断3＜5，执行Step5.15；判断4＜5，执行Step5.15；判断5＝5，执行Step5.15；判断6＞5，j＝2，执行Step5.2；
执行第2次循环，k≤5，
判断1＜5，执行Step5.15；判断2＜5，执行Step5.15；判断3＜5，执行Step5.15；判断4＜5，执行Step5.15；判断5＝5，执行Step5.15；判断6＞5，j＝3，执行Step5.2；
Step5.15、读取x对应的故障特征列表存入knownFeatureList，执行Step5.16；
执行第1次循环，
读取fault1对应的故障特征列表存入knownFeatureList，knownFeatureList＝[fault1，A，B，C]，执行Step5.16；
fault1增添了新故障特征D，读取fault1对应的故障特征列表存入knownFeatureList，knownFeatureList＝[fault1，A，B，C，D]，执行Step5.16；
执行第2次循环，
读取fault2对应的故障特征列表存入knownFeatureList，knownFeatureList＝[fault1，A，B，C，D]，执行Step5.16；
Step5.16、判断y≤knownFeatureList.size()-1，如果是则执行Step5.17，否则执行Step5.20；
fault1与Fault1故障特征比对：
执行第1次循环，当y＝1时，判断1＜3，执行Step5.17；
执行第2次循环，当y＝1时，判断1＜3，执行Step5.17；当y＝2时，判断2＜3，执行Step5.17；
执行第3次循环，当y＝1时，判断1＜3，执行Step5.17；当y＝2时，判断2＜3，执行Step5.17；当y＝3时，判断3＝3，执行Step5.17；
执行第4次循环，当y＝1时，判断1＜3，执行Step5.17；当y＝2时，判断2＜3，执行Step5.17；当y＝3时，判断3＝3，执行Step5.17；当y＝4时，4＞3，执行Step5.20；
执行第5次循环，faultl新增1个故障特征，knownFeatureList.size()-1＝4，当y＝1时，判断1＜4，执行Step5.17；当y＝2时，判断2＜4，执行Step5.17；当y＝3时，判断3＜4，执行Step5.17；当y＝4时，判断4＝4，执行Step5.17；当y＝5时，5＞4，执行Step5.20；
fault2与Fault2故障特征比对：
执行第1次循环，当y＝1时，判断1＜4，执行Step5.17；当y＝2时，判断2＜4，执行Step5.17；当y＝3时，判断3＜4，执行Step5.17；当y＝4时，判断4＝4，执行Step5.17；当y＝5时，判断5＞4，执行Step5.20；
Step5.17、判断featureList.get(k).equals(knownFeatureList.get(y))，如果是执行Step5.18，否则执行Step5.19；
fault1与Fault1故障特征比对：
执行第1次循环，当k＝1，y＝1时，判断A＝featureList.get(1)＝knownFeatureList.get(1)＝A，执行Step5.18；
执行第2次循环，当k＝2，y＝1时，判断B＝featureList.get(2)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝2，y＝2时，判断B＝B，执行Step5.18；
执行第3次循环，当k＝3，y＝1时，判断C＝featureList.get(3)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝3，y＝2时，判断C≠B，执行Step5.19；当k＝3，y＝3时，判断C＝C，执行Step5.18；
执行第4次循环，当k＝4，y＝1时，判断D＝featureList.get(4)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝4，y＝2时，判断D≠B，执行Step5.19；当k＝4，y＝3时，判断D≠C，执行Step5.19；
执行第5次循环，当k＝5，y＝1时，判断E＝featureList.get(5)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝5，y＝2时，判断E≠B，执行Step5.19；当k＝5，y＝3时，判断E≠C，执行Step5.19；当k＝5，y＝4时，判断E≠D，执行Step5.19；
fault2与Fault2故障特征比对：
执行第1次循环，当k＝1，y＝1时，判断A＝featureList.get(1)＝knownFeatureList.get(1)＝A，执行Step5.18；
执行第2次循环，当k＝2，y＝1时，判断B＝featureList.get(2)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝2，y＝2时，判断B＝B，执行Step5.18；
执行第3次循环，当k＝3，y＝1时，判C＝featureList.get(3)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝3，y＝2时，判断C≠B，执行Step5.19；当k＝3，y＝3时，判断C＝C，执行Step5.18；
执行第4次循环，当k＝4，y＝1时，判断D＝featureList.get(4)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝4，y＝2时，判断D≠B，执行Step5.19；当k＝4，y＝3时，判断D≠C，执行Step5.19；当k＝4，y＝4时，判断D＝D，执行Step5.18；
执行第5次循环，当k＝5，y＝1时，判断F＝featureList.get(5)≠knownFeatureList.get(1)＝A，执行Step5.19；当k＝5，y＝2时，判断F≠B，执行Step5.19；当k＝5，y＝3时，判断F≠C，执行Step5.19；当k＝5，y＝4时，判断F≠D，执行Step5.19；
Step5.18、y1＝0，y＝1，k++，执行Step5.14；
fault1与Fault1故障特征比对：
执行第1次循环，y1＝0，y＝1，k＝2，执行Step5.14；执行第2次循环，y1＝0，y＝1，k＝3，执行Step5.14；执行第3次循环，y1＝0，y＝1，k＝4，执行Step5.14；
fault2与Fault2故障特征比对：
执行第1次循环，y1＝0，y＝1，k＝2，执行Step5.14；执行第2次循环，y1＝0，y＝1，k＝3，执行Step5.14；执行第3次循环，y1＝0，y＝1，k＝4，执行Step5.14；执行第4次循环，y1＝0，y＝1，k＝5，执行Step5.14；
Step5.19、y++，执行Step5.16；
fault1与Fault1故障特征比对：
执行第2次循环，y＝2，执行Step5.16；执行第3次循环，y＝2，执行Step5.16；y＝3，执行Step5.16；执行第4次循环，y＝2，执行Step5.16；y＝3，执行Step5.16；y＝4，执行Step5.16；执行第5次循环，y＝2，执行Step5.16；y＝3，执行Step5.16；y＝4，执行Step5.16；y＝5，执行Step5.16；
fault2与Fault2故障特征比对：
执行第2次循环，y＝2，执行Step5.16；执行第3次循环，y＝2，执行Step5.16；y＝3，执行Step5.16；执行第4次循环，y＝2，执行Step5.16；y＝3，执行Step5.16；y＝4，执行Step5.16；y＝5，执行Step5.16；
Step5.20、读取已知服务故障的所有故障特征存入列表totalList，执行Step5.21；
读取列表totalList＝[A，B，C，D]，执行Step5.21；
读取列表totalList＝[A，B，C，D，E]，执行Step5.21；
Step5.21、判断y1＜totalList.size()，如果是执行Step5.22，否则执行Step5.23；
fault1与Fault1故障特征比对：
执行第1次判断，k＝4：判断0＜4，执行Step5.22；判断1＜4，执行Step5.22；判断2＜4，执行Step5.22；判断3＜4，执行Step5.22；
执行第2次判断，k＝5：判断0＜4，执行Step5.22；判断1＜4，执行Step5.22；判断2＜4，执行Step5.22；判断3＜4，执行Step5.22；判断4＝4，执行Step5.23；
fault2与Fault2故障特征比对：
执行第1次判断，k＝5：判断0＜5，执行Step5.22；判断1＜5，执行Step5.22；判断2＜5，执行Step5.22；判断3＜5，执行Step5.22；判断4＜5，执行Step5.22；判断5＝5，执行Step5.23；
Step5.22、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.18，否则y1++，执行Step5.21；
fault1与Fault1故障特征比对：
执行第1次循环，当k＝4，y1＝0时，判断D＝featureList.get(4)≠totalList.get(0)＝A，y1＝1，执行Step5.21；当k＝4，y1＝1时，判断D＝featureList.get(4)≠totalList.get(1)＝B，y1＝2，执行Step5.21；当k＝4，y1＝2时，判断D＝featureList.get(4)≠totalList.get(2)＝C，y1＝3，执行Step5.21；当k＝4，y1＝3时，判断D＝featureList.get(4)＝totalList.get(3)＝D，y1＝4，执行Step5.18；
执行第2次循环，当k＝5，y1＝0时，判断E＝featureList.get(5)≠totalList.get(0)＝A，y1＝1，执行Step5.21；当k＝5，y1＝1时，判断E＝featureList.get(5)≠totalList.get(1)＝B，y1＝2，执行Step5.21；当k＝5，y1＝2时，判断E＝featureList.get(5)≠totalList.get(2)＝C，y1＝3，执行Step5.21；当k＝5，y1＝3时，判断E＝featureList.get(5)≠totalList.get(3)＝D，y1＝4，执行Step5.21；
fault2与Fault2故障特征比对：
执行第1次循环，当k＝5，y1＝0时，判断F＝featureList.get(5)≠totalList.get(0)＝A，y1＝1，执行Step5.21；当k＝5，y1＝1时，判断F＝featureList.get(5)≠totalList.get(1)＝B，y1＝2，执行Step5.21；当k＝5，y1＝2时，判断F＝featureList.get(5)≠totalList.get(2)＝C，y1＝3，执行Step5.21；当k＝5，y1＝3时，判断F＝featureList.get(5)≠totalList.get(3)＝D，y1＝4，执行Step5.21；当k＝5，y1＝4时，判断F＝featureList.get(5)≠totalList.get(4)＝E，y1＝5，执行Step5.21；
5.23、将featureList.get(k)作为新故障特征添加在已知故障x类别下，执行Step5.18；
fault1与Fault1故障特征比对：将featureList.get(5)＝E作为新故障特征添加在已知故障fault1类别下，执行Step5.18；
fault2与Fault2故障特征比对：将featureList.get(5)＝F作为新故障特征添加在已知故障fault2类别下，执行Step5.18；
Step5.24、将j类别下的newFaultListt*(d-1)存入x类的knownFaultListo*u，执行Step5.25；
x＝3，将Fault3类别下的newFaultList5*4存入fault3类的knownFaultLists*4，执行Step5.25；
Step5.25、读取j类别对应的服务故障特征列表featureList，执行Step5.26；
读取Fault3类别下的服务故障特征featureList＝[Fault3，B，C，D，G]，执行Step5.26；
Step5.26、k＝1，y1＝0，执行Step5.27；
Step5.27、读取已知服务故障的所有服务故障特征存入列表totalList，执行Step5.28；
所有服务故障特征列表totalList＝[A，B，C，D，E，F]，执行Step5.28；
Step5.28、判断k≤featureList.size()-1，如果是执行Step5.29，否则x＝1，j++，执行Step5.2；
当k＝1时，判断1≤4，执行Step5.29；当k＝2时，判断2≤4，执行Step5.29；当k＝3时，判断3≤4，执行Step5.29；当k＝4时，判断4＝4，执行Step5.29；当k＝5时，判断5＞4，x＝1，j＝4，执行Step5.2；
Step5.29、判断y1＜totalList.size()，如果是执行Step5.30，否则执行Step5.33；
执行第1次循环，当y1＝0，判断0＜6，执行Step5.30；当y1＝1，判断1＜6，执行Step5.30；
执行第2次循环，当y1＝0，判断0＜6，执行Step5.30；当y1＝1，判断1＜6，执行Step5.30；当y1＝2，判断2＜6，执行Step5.30；
执行第3次循环，当y1＝0，判断0＜6，执行Step5.30；当y1＝1，判断1＜6，执行Step5.30；当y1＝2，判断2＜6，执行Step5.30；当y1＝3，判断3＜6，执行Step5.30；
执行第4次循环，当y1＝0，判断0＜6，执行Step5.30；当y1＝1，判断1＜6，执行Step5.30；当y1＝2，判断2＜6，执行Step5.30；当y1＝3，判断3＜6，执行Step5.30；当y1＝4，判断4＜6，执行Step5.30；当y1＝5，判断5＜6，执行Step5.30；当y1＝6，执行Step5.33；
Step5.30、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.31，否则执行Step5.32；
执行第1次循环，当k＝1，y1＝0时，判断B＝featureList.get(1)≠totalList.get.g(0)＝A，执行Step5.32；当k＝1，y1＝1时，判断B＝featureList.get(1)＝totalList.get.g(1)＝B，执行Step5.31；
执行第2次循环，当k＝2，y1＝0时，判断C＝featureList.get(2)≠totalList.get.g(0)＝A，执行Step5.32；当k＝2，y1＝1时，判断C＝featureList.get(2)≠totalList.get.g(1)＝B，执行Step5.32；当k＝2，y1＝2时，判断C＝featureList.get(2)＝totalList.get.g(2)＝C，执行Step5.31；
执行第3次循环，当k＝3，y1＝0时，判断D＝featureList.get(3)≠totalList.get.g(0)＝A，执行Step5.32；当k＝3，y1＝1时，判断D＝featureList.get(3)≠totalList.get.g(1)＝B，执行Step5.32；当k＝3，y1＝2时，判断D＝featureList.get(3)≠totalList.get.g(2)＝C，执行Step5.32；当k＝3，y1＝3时，判断D＝featureList.get(3)＝totalList.get.g(3)＝D，执行Step5.31；
执行第4次循环，当k＝4，y1＝0时，判断G＝featureList.get(4)≠totalList.get.g(0)＝A，执行Step5.32；当k＝4，y1＝1时，判断G＝featureList.get(4)≠totalList.get.g(1)＝B，执行Step5.32；当k＝4，y1＝2时，判断G＝featureList.get(4)≠totalList.get.g(2)＝C，执行Step5.32；当k＝4，y1＝3时，判断G＝featureList.get(4)≠totalList.get.g(3)＝D，执行Step5.32；当k＝4，y1＝4时，判断G＝featureList.get(4)≠totalList.get.g(4)＝E，执行Step5.32；当k＝4，y1＝5时，判断G＝featureList.get(4)≠totalList.get.g(5)＝F，执行Step5.32；
Step5.31、y1＝0，k++，执行Step5.28；y1＝0，k＝2，执行Step5.28；y1＝0，k＝3，执行Step5.28；y1＝0，k＝4，执行Step5.28；
Step5.32、y1++，执行Step5.29；
执行第1次循环，y1＝1，执行Step5.29；
执行第2次循环，y1＝1，执行Step5.29；y1＝2，执行Step5.29；
执行第3次循环，y1＝1，执行Step5.29；y1＝2，执行Step5.29；y1＝3，执行Step5.29；
执行第4次循环，y1＝1，执行Step5.29；y1＝2，执行Step5.29；y1＝3，执行Step5.29；y1＝4，执行Step5.29；y1＝5，执行Step5.29；y1＝6，执行Step5.29；
Step5.33、将featureList.get(k)作为新故障特征添加在j类别下，执行Step5.31；
将featureList.get(4)＝G作为新故障特征添加在fault3类别下，执行Step5.31；
通过循环执行Step5.1至Step5.33，实现了服务故障与服务故障特征的动态扩充、服务故障与服务故障特征关联关系的动态更新，已知服务故障与已知服务故障特征关联网状图如图7所示，动态更新服务故障与服务故障特征关联网状图如图8所示。
上面结合附图对本发明的具体实施方式作了详细说明，但是本发明并不限于上述实施方式，在本领域普通技术人员所具备的知识范围内，还可以在不脱离本发明宗旨的前提下作出各种变化。

Claims (5)

1.一种云计算环境下服务故障模型动态建立方法，其特征在于：所述方法步骤包括：
Step1、预处理服务运行数据：对服务运行数据集进行方差计算，根据方差计算结果删除运行数据集中无效的属性数据列，获得预处理服务运行数据集列表；
Step2、抽取服务故障：对预处理服务运行数据集列表进行服务故障判断，抽取服务故障数据；
Step3、确定服务故障分类：对抽取出的服务故障数据通过多属性的不同表现形式产生不同服务故障的分类方式，对服务故障数据进行分类，并对分类后的服务故障数据进行类别标记；
Step4、抽取服务故障特征：对分类后的服务故障分别抽取服务故障特征，抽取出的服务故障特征代表该类故障发生时所产生的故障表现形式；
Step5、动态关联服务故障与服务故障特征：对分类后的服务故障与已知服务故障进行朴素贝叶斯概率计算，识别出新产生的服务故障；对服务故障中抽取的服务故障特征与已知服务故障特征进行比对，识别出新产生的服务故障特征；分析服务故障与服务故障特征间关联并动态更新已知服务故障与已知服务故障特征间关联；
所述Step5具体如下：
Step5.1、设置j＝1，x＝1，执行Step5.2；
Step5.2、判断j≤n，如果是执行Step5.3，否则结束执行；其中，n表示服务故障分类后的类别总数；
Step5.3、读取j类别下的列表newFaultList1t*d，然后将列表中的类别标记属性列删除后存入列表newFaultListt*(d-1)，执行Step5.4；其中，t、d表示列表newFaultList1的行、列；
Step5.4、判断x≤num：如果是执行Step5.5，否则执行Step5.24；其中，num表示已知服务故障类别总数；
Step5.5、读取x类别下的故障数据存入列表knownFaultListo*u，执行Step5.6；其中，o、u表示列表knownFaultList的行、列；
Step5.6、设置count＝0，e＝0，执行Step5.7；其中，count表示概率值大于1的总次数；
Step5.7、判断e＜newFaultList.size()，如果是执行Step5.8，否则执行Step5.11；其中，newFaultList.size()表示列表newFaultList的数据总条数大小；
Step5.8、j类别下的newFaultList.get(e)与x类别下的knownFaultListo*u采用公式(1)进行朴素贝叶斯概率计算，执行Step5.9；
Figure FDA0003629746540000021
其中，newFaultList.get(e)表示列表newFaultList的第e条数据，j类别下二维列表newFaultListt*(d-1)为待分类项，服务故障二维列表newFaultListt*(d-1)的特征属性集为X＝{X1,X2,...,Xd-1}，d-1表示列表newFaultList有d-1个属性列，已知故障列表knownFaultList类别集合为Y＝{y1,y2,...,ynum}，P(Y|X)表示j类别下的特征属性集X属于Y类别的概率，P(Y)表示已知故障列表knownFaultList中各类别分别发生的概率，即先验概率，P(X|Y)表示特征属性集X下的各属性值在已知服务故障的每个类别Y中出现的概率，P(X)表示特征属性集X分别发生的概率；
Step5.9、判断newFaultList.get(e)概率值>1，如果是执行Step5.10，否则e++，执行Step5.7；
Step5.10、count++，e++，执行Step5.7；
Step5.11、判断
Figure FDA0003629746540000022
如果是执行Step5.12，否则x++，执行Step5.4；
Step5.12、读取j类别对应的服务故障特征列表featureList，执行Step5.13；
Step5.13、设置k＝1，y＝1，y1＝0，执行Step5.14；其中，y1表示已知服务故障特征值对应的下标；
Step5.14、判断k≤featureList.size()-1，如果是执行Step5.15，否则x＝1，j++，执行Step5.2；其中，featureList.size()表示列表featureList的数据个数的大小；
Step5.15、读取x对应的故障特征列表存入knownFeatureList，执行Step5.16；
Step5.16、判断y≤knownFeatureList.size()-1，如果是则执行Step5.17，否则执行Step5.20；其中，knownFeatureList.size()表示列表knownFeatureList的数据个数的大小；
Step5.17、判断featureList.get(k).equals(knownFeatureList.get(y))，如果是执行Step5.18，否则执行Step5.19；其中，featureList.get(k).equals(knownFeatureList.get(y))表示列表featureList中第k个数据的值等于列表knownFeatureList中第y个数据的值；
Step5.18、y1＝0，y＝1，k++，执行Step5.14；
Step5.19、y++，执行Step5.16；
Step5.20、读取已知服务故障的所有故障特征值存入列表totalList，执行Step5.21；
Step5.21、判断y1＜totalList.size()，如果是执行Step5.22，否则执行Step5.23；其中，totalList.size()表示列表totalList的数据个数的大小；
Step5.22、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.18，否则y1++，执行Step5.21；其中，featureList.get(k).equals(totalList.get(y1))表示列表featureList中第k个数据的值等于列表totalList中第y1个数据的值；
Step5.23、将featureList.get(k)作为新故障特征添加在已知故障x类别下，执行Step5.18；
Step5.24、将j类别下的newFaultListt*(d-1)存入x类的knownFaultListo*u，执行Step5.25；
Step5.25、读取j类别对应的服务故障特征列表featureList，执行Step5.26；
Step5.26、k＝1，y1＝0，执行Step5.27；
Step5.27、读取已知服务故障的所有服务故障特征存入列表totalList，执行Step5.28；
Step5.28、判断k≤featureList.size()-1，如果是执行Step5.29，否则x＝1，j++，执行Step5.2；
Step5.29、判断y1＜totalList.size()，如果是执行Step5.30，否则执行Step5.33；
Step5.30、判断featureList.get(k).equals(totalList.get(y1))，如果是执行Step5.31，否则执行Step5.32；
Step5.31、y1＝0，k++，执行Step5.28；
Step5.32、y1++，执行Step5.29；
Step5.33、将featureList.get(k)作为新故障特征添加在j类别下，执行Step5.31。
2.根据权利要求1所述的云计算环境下服务故障模型动态建立方法，其特征在于：所述Step1具体如下：
Step1.1、初始化云计算环境下监测到的服务运行数据集D，从服务运行数据集D中提取出服务运行数据存入服务运行数据列表ServiceDataList，ServiceDataListr*c＝[[J1],[J2],[J3],...,[Jr]]，[J1]＝[M1,M2,M3,...,Mc]，其中，J1为第1条服务运行数据，Jr为第r条服务运行数据，Mc为第1条服务运行数据的第c个属性，r为服务运行数据列表中数据总条数，c为每条服务运行数据属性的总数，设置g＝0，h＝0，执行Step1.2；
Step1.2、判断g＜ServiceDataList.get(h).size()，如果是执行Step1.3；否则执行Step2；其中，ServiceDataList.get(h).size()表示二维服务运行数据列表ServiceDataList中第h条服务运行数据属性个数的大小；
Step1.3、初始化一个空列表resultList，此列表用来存放属性列的服务运行数据，执行Step1.4；
Step1.4、判断h＜ServiceDataList.size()，如果是执行Step1.5；否则执行Step1.6；其中，ServiceDataList.size()表示二维服务运行数据列表ServiceDataList的数据总条数大小；
Step1.5、将ServiceDataList.get(h).get(g)存入到列表resultList，h++，执行Step1.4；其中，ServiceDataList.get(h).get(g)表示二维服务运行数据列表ServiceDataList中第h条服务运行数据的第g个属性的值；
Step1.6、设置a＝0，属性列数据总和sum＝0，属性列数据平均值average＝0，属性列数据方差variance＝0，v＝0，判断a＜resultList.size()，如果是执行Step1.7，否则执行Step1.8；其中，resultList.size()表示列表resultList的数据个数的大小；
Step1.7、计算数据总和sum+＝resultList.get(a)，a++，执行Step1.6；其中，resultList.get(a)表示列表resultList中第a个数据的值；
Step1.8、计算数据平均值
Figure FDA0003629746540000041
执行Step1.9；
Step1.9、设置b＝0，执行Step1.10；
Step1.10、判断b＜resultList.size()，如果是执行Step1.11，否则执行Step1.12；
Step1.11、v+＝(resultList.get(b)-average)2，b++，执行Step1.9；
Step1.12、计算方差值
Figure FDA0003629746540000042
判断variance＞0，如果是保留属性列表resultList，并存入预处理服务运行数据集列表，否则删除该属性列表resultList，g++，执行Step1.2。
3.根据权利要求1或2所述的云计算环境下服务故障模型动态建立方法，其特征在于：所述Step2具体如下：
Step2.1、设置s＝0，执行Step2.2；
Step2.2、读取预处理服务运行数据集列表存入二维列表dataList，执行Step2.3；
Step2.3、判断s＜dataList.size()，如果是执行Step2.4；否则执行Step3；其中，dataList.size()表示列表dataList的数据总条数大小；
Step2.4、设置w＝0，执行Step2.5；
Step2.5、判断w＜dataList.get(s).size，如果是执行Step2.6，否则执行Step2.7；其中，dataList.get(s).size()表示二维列表dataList中第s条服务运行数据属性个数的大小；
Step2.6、判断dataList.get(s).get(w)＞60，如果是执行Step2.8；否则执行Step2.9；其中，dataList.get(s).get(w)表示列表dataList中第s条服务运行数据的第w个属性的值；
Step2.7、dataList.get(s)为正常数据，s++，执行Step2.3；其中，dataList.get(s)表示列表dataList的第s条数据；
Step2.8、dataList.get(s)为故障数据，存入二维列表newFaultdataList，s++，执行Step2.3；
Step2.9、w++，执行Step2.5。
4.根据权利要求3所述的云计算环境下服务故障模型动态建立方法，其特征在于：所述Step3具体如下：
Step3.1、设置i＝0，tag＝0，q1＝newFaultdataList.get(i).size()，新建二维列表tempList，执行Step3.2；其中，newFaultdataList.get(i).size()表示二维列表newFaultdataList中第i条服务运行数据属性个数的大小；
Step3.2、读取服务故障数据集二维列表newFaultdataList，执行Step3.3；
Step3.3、判断i＜newFaultdataList.size()，如果是执行Step3.4，否则执行Step4；其中，newFaultdataList.size()表示二维列表newFaultdataList的数据总条数大小；
Step3.4、设置p＝0，q＝1，执行Step3.5；
Step3.5、判断p＜newFaultdataList.get(i).size()，如果是执行Step3.6，否则i++，执行Step3.3；
Step3.6、判断newFaultdataList.get(i).get(p)＞60，如果是执行Step3.7，否则p++，q++，执行Step3.5；其中，newFaultdataList.get(i).get(p)表示二维列表newFaultdataList中第i条服务运行数据的第p个属性的值；
Step3.7、设置f＝p+1，执行Step3.8；
Step3.8、判断f＜newFaultdataList.get(i).size()-p，如果是执行Step3.9，否则将newFaultdataList.get(i)存入的二维列表newFaultList1，并标记类别为Faultq，i++，执行Step3.3；其中，newFaultdataList.get(i)表示二维列表newFaultdataList的第i条数据；
Step3.9、判断newFaultdataList.get(i).get(f)＜60：如果是执行Step3.10，否则执行Step3.11；
Step3.10、f++，执行Step3.8；
Step3.11、记录newFaultdataList.get(i).get(f)下标f赋给tag，执行Step3.12；
Step3.12、新建一个空的一维列表List，List.add(p)，List.add(tag)，执行Step3.13；其中，List.add(p)表示在列表List中添加p值，List.add(tag)表示在列表List中添加tag值；
Step3.13、判断tempList是否包含List列表中p和tag的值，如果是执行Step3.14，否则执行Step3.15；
Step3.14、将newFaultdataList.get(i)存入二维列表newFaultList1，获取到tempList中对应列表最后一列的值value，并标记类别为Faultvalue，i++，执行Step3.3；
Step3.15、设置q1++，执行Step3.16；
Step3.16、新建一个空的一维列表List1，List1.add(p)，List1.add(tag)，List1.add(q1)，tempList.add(List1)，执行Step3.18；其中，List1.add(p)表示在列表List1中添加p值，List1.add(tag)表示在列表List1中添加tag值，List1.add(q1)表示在列表List1中添加q1值，tempList.add(List1)表示把列表List1添加到列表tempList；
Step3.17、将newFaultdataList.get(i)存入的二维列表newFaultList1并标记类别为Faultq1，i++，执行Step3.3。
5.根据权利要求4所述的云计算环境下服务故障模型动态建立方法，其特征在于：所述Step4具体如下：
Step4.1、设置j＝0，k＝1，执行Step4.2；
Step4.2、判断j＜n，如果是执行Step4.3，否则执行Step5；其中，n表示服务故障分类后的类别总数；
Step4.3、读取第j类服务故障的二维列表newFaultList1t*d，执行Step4.4；其中，t、d表示列表newFaultList1的行、列；
Step4.4、抽取第j类服务故障的若干服务故障特征Yk，执行Step4.5；其中，k＝1,2,3,…,m，m表示服务故障特征值总数；
Step4.5、判断k≤m，如果是执行Step4.6，否则执行Step4.7；
Step4.6、将j类的服务故障特征Yk存入服务故障特征列表featureList，k++，执行Step4.5；
Step4.7、j++，执行Step4.2。
CN202110033483.5A 2021-01-12 2021-01-12 一种云计算环境下服务故障模型动态建立方法 Active CN112882887B (zh)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202110033483.5A CN112882887B (zh) 2021-01-12 2021-01-12 一种云计算环境下服务故障模型动态建立方法

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202110033483.5A CN112882887B (zh) 2021-01-12 2021-01-12 一种云计算环境下服务故障模型动态建立方法

Publications (2)

Publication Number Publication Date
CN112882887A CN112882887A (zh) 2021-06-01
CN112882887B true CN112882887B (zh) 2022-08-09

Family

ID=76044690

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202110033483.5A Active CN112882887B (zh) 2021-01-12 2021-01-12 一种云计算环境下服务故障模型动态建立方法

Country Status (1)

Country Link
CN (1) CN112882887B (zh)

Citations (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0610583A1 (en) * 1993-02-08 1994-08-17 International Business Machines Corporation Multizone relocation facility computer memory system
US6704888B1 (en) * 1999-02-08 2004-03-09 Bull, S.A. Process and tool for analyzing and locating hardware failures in a computer
CN101251564A (zh) * 2008-04-08 2008-08-27 昆明理工大学 一种利用可拓学与粗糙集理论相结合的电力变压器故障诊断方法
CN109921938A (zh) * 2019-03-15 2019-06-21 昆明理工大学 一种云计算环境下故障检测方法
CN110502445A (zh) * 2019-08-29 2019-11-26 中国电子科技集团公司第十五研究所 软件故障严重等级判定方法及装置、模型训练方法及装置
CN111695607A (zh) * 2020-05-25 2020-09-22 北京信息科技大学 基于lstm增强模型的电子设备故障预测方法
CN112000791A (zh) * 2020-08-26 2020-11-27 哈电发电设备国家工程研究中心有限公司 一种电机故障知识抽取系统及方法
CN112035286A (zh) * 2020-08-25 2020-12-04 海尔优家智能科技（北京）有限公司 故障原因的确定方法及装置、存储介质、电子装置

Patent Citations (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0610583A1 (en) * 1993-02-08 1994-08-17 International Business Machines Corporation Multizone relocation facility computer memory system
US6704888B1 (en) * 1999-02-08 2004-03-09 Bull, S.A. Process and tool for analyzing and locating hardware failures in a computer
CN101251564A (zh) * 2008-04-08 2008-08-27 昆明理工大学 一种利用可拓学与粗糙集理论相结合的电力变压器故障诊断方法
CN109921938A (zh) * 2019-03-15 2019-06-21 昆明理工大学 一种云计算环境下故障检测方法
CN110502445A (zh) * 2019-08-29 2019-11-26 中国电子科技集团公司第十五研究所 软件故障严重等级判定方法及装置、模型训练方法及装置
CN111695607A (zh) * 2020-05-25 2020-09-22 北京信息科技大学 基于lstm增强模型的电子设备故障预测方法
CN112035286A (zh) * 2020-08-25 2020-12-04 海尔优家智能科技（北京）有限公司 故障原因的确定方法及装置、存储介质、电子装置
CN112000791A (zh) * 2020-08-26 2020-11-27 哈电发电设备国家工程研究中心有限公司 一种电机故障知识抽取系统及方法

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
基于日志数据的分布式软件系统故障诊断综述;贾统等;《软件学报》;20200715;1997-2018 *
面向Ethercat主从站设备的故障检测与故障预测方法研究;罗腾宇;《中国优秀硕士学位论文全文数据库（电子期刊）》;20200731;C029-150 *

Also Published As

Publication number Publication date
CN112882887A (zh) 2021-06-01

Similar Documents

Publication Publication Date Title
Chen et al. Colnet: Embedding the semantics of web tables for column type prediction
Ferreira et al. Approaching process mining with sequence clustering: Experiments and findings
CN106570128A (zh) 一种基于关联规则分析的挖掘算法
CN110472082B (zh) 数据处理方法、装置、存储介质及电子设备
CN107844533A (zh) 一种智能问答系统及分析方法
CN109213843A (zh) 一种垃圾文本信息的检测方法及装置
CN108304328B (zh) 一种众包测试报告的文本描述生成方法、系统及装置
US20220277188A1 (en) Systems and methods for classifying data sets using corresponding neural networks
JP2020024534A (ja) 画像分類装置及びプログラム
CN112416369A (zh) 一种面向异构混合环境的智能化部署方法
CN114139636B (zh) 异常作业处理方法及装置
US20190220388A1 (en) Boundary search test support device and boundary search test support method
CN112257332B (zh) 一种仿真模型的评估方法及装置
Lichtenstein et al. Attribute-driven case notion discovery for unlabeled event logs
CN112882887B (zh) 一种云计算环境下服务故障模型动态建立方法
CN115130617B (zh) 一种自适应卫星数据模式不断增长的检测方法
WO2023273171A1 (zh) 图像处理方法、装置、设备和存储介质
CN109739840A (zh) 数据空值处理方法、装置及终端设备
Wang et al. A knowledge discovery case study of software quality prediction: Isbsg database
Bicevskis et al. Towards data quality runtime verification
CN114595262A (zh) 一种市政道路epc项目招标清单的快速生成方法及系统
CN113836005A (zh) 一种虚拟用户的生成方法、装置、电子设备和存储介质
WO2021137689A1 (en) System for library materials classification and a method thereof
CN112837026A (zh) 一种交付物循环依赖的分析方法、装置、设备及存储介质
CN112433755A (zh) 一种基于多类特征和多个度量指标的微服务架构识别方法

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant