文献复现——A New Geometric Mean FMEA Method Based on Information Quality

实现了作者的模型，并且添加了简单的数据预处理：

#作者提出了一个新的FMEA方法，主要是对原有的RPN计算方法改进
#1、构建模糊评价矩阵，如果有 N个失效模式，那么就构建N×3的模糊评价矩阵
#N行有N个失效模式FM，3列3个不同的指标，S O D
#模糊评价矩阵的元素为(a,b,c,....)是专家对该指标的满意度评价
#2、计算模糊矩阵中每个元素的广义信息质量，生成广义信息质量矩阵
#3、对广义信息质量矩阵进行修正(qu_matrix/max(qu_matrix))，得到几何平均权重矩阵(0.3365,0.4158,0.2475)

#4、通过几何平均权重矩阵计算每个效模式的RPN
import numpy as np
import pandas as pd
import math
#1、根据专家意见构建模糊评价矩阵
# fuzzy_list=[[(0.8193,0.0771,0.1033),(0.0545,0.3105,0.6346),(0.2191,0.4894,0.2914)],
#             [(0.7224,0.1373,0.1399),(0.0545,0.3104,0.6346),(0.8250,0.0776,0.1040)],
#             [(0.8709,0.1039,0.0253),(0.0233,0.0722,0.2042),(0.2191,0.4892,0.2914)],
#             [(0.3669,0.4475,0.1854),(0.0233,0.0722,0.9043) ,(0.0545,0.3104,0.6346)],
#             [(0.3669,0.4475,0.1854) ,(0.1504,0.4446,0.4045) ,(0.7546,0.1373,0.1075)],
#             [(0.3669,0.4475,0.1854) ,(0.1504,0.4446,0.4045) ,(0.7546,0.1373,0.1075)],
#             [(0.7227,0.1374,0.1400) ,(0.1504,0.4446,0.4045) ,(0.0545,0.3104,0.6346)],
#             [(0.8709,0.1039,0.0253) ,(0.0233,0.0722,0.9042),(0.2191,0.4894,0.2914)],
#             [(0.3669,0.4475,0.1854) ,(0.1504,0.4446,0.4045) ,(0.7546,0.1373,0.1075)],
#             [(0.7966,0.1070,0.1135) ,(0.3092,0.1103,0.5671),(0.3365,0.4158,0.2475)]]
# fuzzy_matrix=np.array(fuzzy_list);#转换为矩阵
#x,y,z=fuzzy_matrix.shape;
#数据预处理
def checkdata(fuzzy_matrix):
    x,y,z=fuzzy_matrix.shape;
    m=0
    for i in range(0,x):
        for j in range(0,y):
            sum=0
            for k in range(0,z):
                sum=sum+fuzzy_matrix[i,j,k]
            if(round(sum,0)!=1):
                m=m+1
                print("(",i+1,",",j+1,")")
                for k_ in range(0,z):
                    fuzzy_matrix[i,j,k_]=fuzzy_matrix[i,j,k_]/sum
    print("保留0位小数后，一共有{0}个数据不符合条件,现在已经修改".format(m))
    return fuzzy_matrix;
#2、计算广义信息质量
#2.0向量得自身长度得平方,z是大小
def selfDis2(pi,z):
    sum=0.0
    for i in range(0,z):
        sum=sum+pi[i]*pi[i]
    return sum;


#2.1 计算pi与pj之间的距离:元组
def distance(p_i,p_j):
    #转换为行向量
    vector_i=np.array(p_i);
    vector_j = np.array(p_j);
    #计算差值：
    vector_dif_T=vector_i-vector_j;#这是列项量
    line=vector_dif_T.shape[0];#获取行
    vector_dif_T=vector_dif_T.reshape(line,1);#重新塑性，否则错误
    vector_dif_line=vector_dif_T.reshape(1,line);#转置
    d=np.dot(vector_dif_line,vector_dif_T);#矩阵相乘
    d=d[0,0]
    d=pow(d,1/2);
    return round(d,4);
#2.2 计算相似度
def sim(p_i,p_j):
    return 1-distance(p_i,p_j);
#2.3构建每一个指标的sim矩阵,距离采用全部的
#返回矩阵
def simArray(fmatrix):
    x,y,z=fmatrix.shape;
    p=1
    simMatrix=[]
    for i in range(0,x):
        tmp = []
        for j in range(0,y):
                pi=fmatrix[i,j,:];
                sum=0.0
                for i_ in range(0,x):
                    for j_ in range(0,y):
                        if(i==i_ and j==j_):
                            continue;
                        else:
                             pj=fmatrix[i_,j_,:];
                             sum=sum+sim(pi,pj);
                tmp.append(round(sum,4))
        simMatrix.append(tmp);
    simM=np.array(simMatrix)
    return simM

#2.4构建信用矩阵crdi
def crdi(fmatrix):
    x,y,z=fmatrix.shape;
    sup=simArray(fmatrix);
    sum=0.0
    for i in range(0,x):
        for j in range(0,y):
            sum=sum+sup[i,j]
    for i in range(0,x):
        for j in range(0,y):
            sup[i,j]=sup[i,j]/sum
    return sup;
#2.5构建广义信息质量矩阵
def qu(fmatrix):
    crdiMatrix_=crdi(fmatrix);#信任矩阵
    print(type(crdiMatrix_))
    x,y,z=fmatrix.shape;
    list_line=[]
    for i in range(0,x):
        list_column=[]
        for j in range(0,y):
            pi=fmatrix[i,j,:];#pi
            doublePi=selfDis2(pi,z);
            exp=crdiMatrix_[i,j]
            expCrdi=pow(math.e,exp)
            sum=expCrdi*doublePi;
            list_column.append(sum)
        list_line.append(list_column)
    quMatrix=np.array(list_line)
    # print("广义信息质量矩阵")
    # print(quMatrix)
    return quMatrix
#对广义信息质量矩阵进行修正，得到几何平均权重矩阵
def weightMatrix(fmatrix):
    quMatrix=qu(fmatrix);#广义矩阵
    maxValue=quMatrix.max();
    x,y=quMatrix.shape;
    for i in range(0,x):
        for j in range(0,y):
            quMatrix[i,j]=quMatrix[i,j]/maxValue;
    #print("Geometric mean Matrix")
    #print(quMatrix)
    return quMatrix
#利用几何均值法生成新的RPN矩阵
def geometricMean(fmatrix):
    fmatrix = checkdata(fmatrix);#数据预处理
    geoMatrix=weightMatrix(fmatrix);#生成geometric mean metric
    x,y,z=fmatrix.shape;
    finalResult=[];#最终的结果矩阵，预设大小为3*10，最后需要转置
    for q in range(0,z):
        #q代表good、average、poor
        tmp_q=[];#临时矩阵
        for i in range(0,x):
           rqn=0.0;
           w_line=0.0;#在权重矩阵中计算每一行的权重之和
           m_line = 1;  # 作为连乘的结果
           for j in range(0,y):
               w_line=w_line+geoMatrix[i,j];
               m_line=m_line*pow(fmatrix[i,j,q],geoMatrix[i,j]);
           w_line = 1 / w_line;  # 作为指数
           rqn=pow(m_line,w_line);
           tmp_q.append(rqn);
        finalResult.append(tmp_q);
    finalR=np.array(finalResult);#转为矩阵
    x,y=finalR.shape
    #转置，不要用reshape，reshape是按照顺序以及设置的x,y，一行一行的进行切割，不是真正意义上的转置
    finalResult=[]
    for j in range(0,y):
        tmp = []
        for i in range(0,x):
            tmp.append(finalR[i,j]);
        finalResult.append(tmp);
    return np.array(finalResult);
#生成等级RNK等级
def rankMake(fmatrix):
    geoMetrix=geometricMean(fmatrix);
    print("平均几何均值矩阵 Geometric Mean Matrix")
    print(geoMetrix)
    x,y=geoMetrix.shape;#权重值未0.1 0.3 0.6
    weight=[0.1,0.3,0.6];
    results=[]
    for i in range(0,x):
        str_="A"+str(i+1)
        tmp=[]
        sum=0.0
        tmp.append(str_)
        for j in range(0,y):
            sum=sum+geoMetrix[i,j]*weight[j]
        tmp.append(sum);
        results.append(tmp)
    results=np.array(results)#这就是新合成的RPN
    # print("新合成的RPN")
    # print(results)
    #应该加上rank等级这一列
    results=results[results[:,1].argsort()]#根据每一列的值进行排序，调整行的顺序
    x, y = results.shape;
    finals=[]
    for i in range(0,x):
        tmp=[]
        for j in range(0,y):
            tmp.append(results[i,j])
        tmp.append(10-i)
        finals.append(tmp)
    results=np.array(finals)
    results=results[results[:,0].argsort()]
    print(results)
    return results;
if __name__ == '__main__':
    #fuzzy_list=[[(0.8193,0.0771,0.1033),(0.0545,0.3105,0.6346),(0.2191,0.4894,0.2914)]]
    #(good,average,poor)
    fuzzy_list=[[(0,0,1),(0,0,1),(0,0,1)],
                [(0,0,1),(0,0,1),(0,0,1)],
                [(0,0,1),(0,0,1),(0,0,1)]]
    fuzzy_matrix = np.array(fuzzy_list);
    # weightMatrix(fuzzy_matrix)
    #print(geometricMean(fuzzy_matrix))
    #simArray(fuzzy_matrix)
    # crdi(fuzzy_matrix)
    rankMake(fuzzy_matrix)