层次分析法python代码

main.py 

#层次分析法实现代码（O-C-P单层次）
import numpy as np
import pandas as pd
import JudgeMatrix as JM
#确定评价指标
indexes=int(input('输入评价指标数量:'))
Indexes=[None,]
for i in range(indexes):
    index=input(f'输入第{i+1}个评价指标')
    Indexes.append(index)

#确定评价方案
plans=int(input('输入评价方案数量:'))
Plans=[None,]
for i in range(plans):
    plan=input(f'输入第{i+1}个评价方案')
    Plans.append(plan)

#构建判断矩阵
#构建O-C判断矩阵
while True:
    print('正在构建O-C判断矩阵')
    Judge_OC=np.eye(indexes,indexes)
    for i in range(1,indexes+1):
        for j in range(i+1,indexes+1):
            rec=input(f'输入指标{Indexes[i]}对指标{Indexes[j]}的重要性分值:[输入格式:score,flag  flag=0,表示前面指标对后面指标的重要性；flag=1'
                               f'表示后面指标对前面指标的重要性]')
            x=rec.split(',')
            flag=int(x[-1].strip())
            x=int(x[0].strip())
            if flag==0:
             Judge_OC[i-1,j-1]=x
             Judge_OC[j-1,i-1]=1/x
            else:
                Judge_OC[i - 1, j - 1] = 1/x
                Judge_OC[j - 1, i - 1] =  x
    print('O-C判断矩阵如下:')
    print(Judge_OC)
    result=JM.Judge_Matrix_Check(Judge_OC)
    if result==True:
        print('各指标权重如下:')
        W_OC=JM.Weight(Judge_OC)
        print(W_OC)
        break

#构建C-P判断矩阵
CP_Array=np.empty(shape=(indexes,plans))
for k in range(1,indexes+1):
    while True:
        print(f'正在构建C[{Indexes[k]}]-P判断矩阵')
        Judge_CP=np.eye(plans,plans)
        for i in range(1,plans+1):
            for j in range(i+1,plans+1):
                rec=(input(f'对于{Indexes[k]}指标,输入方案{Plans[i]}对方案{Plans[j]}的重要性分值:[输入格式:score,flag  flag=0,表示前面指标对后面指标的重要性；flag=1'
                    f'表示后面指标对前面指标的重要性]'))
                x = rec.split(',')
                flag = int(x[-1].strip())
                x = int(x[0].strip())
                if flag == 0:
                    Judge_CP[i - 1, j - 1] = x
                    Judge_CP[j - 1, i - 1] = 1 / x
                else:
                    Judge_CP[i - 1, j - 1] = 1 / x
                    Judge_CP[j - 1, i - 1] = x
        print('C[{Indexes[k]}]-P判断矩阵如下:')
        print(Judge_CP)
        result=JM.Judge_Matrix_Check(Judge_CP)
        if result==True:
            print('对于{Indexes[k]}指标,各方案权重如下:')
            W_CP=JM.Weight(Judge_CP)
            print(W_CP)
            CP_Array[k-1]=W_CP
            break

score_list=[None,]
#计算各方案综合得分
for i in range(1,plans+1):
    score=np.sum(W_OC*CP_Array[:,i-1])
    score_list.append(score)
    print(f'方案{Plans[i]}的得分为:{score}')

Final_Result=pd.Series(index=Plans[1:],data=score_list[1:])
print(Final_Result.sort_values(ascending=True))

JudgeMatrix.py 

import numpy as np
class Constant:
    RI_dict=[None,0,0,0.52,0.89,1.12,1.26,1.36,1.41,1.46,1.49,1.52,1.54,1.56,1.58,1.59]

#判断矩阵一致性检验,M:判断矩阵
def Judge_Matrix_Check(M:np.array) ->bool:
    #计算矩阵阶数
    n=M.shape[0]
    # 第一步：计算一致性指标CI
    values,vectors=np.linalg.eig(M)
    max_value=max(values)
    CI=(max_value-n)/(n-1)
    #第二步： 查表获知平均随机一致性指标RI
    RI=Constant.RI_dict[n]
    #第三步： 计算一致性比例CR
    CR=CI/RI
    #第四步： 判断CR是否小于0.1
    print(f'一致性比例={CR}')
    if CR<0.1:
        print('通过一致性检验！')
        return True
    else:
        print('不通过一致性检验,请修改判断矩阵！')
        return False

#根据判断矩阵计算权重（三种方法）
#法一：算术平均数
def Weight_By_A(M:np.array):
    #按列归一化
    M1=M/M.sum(axis=0)
    #按行计算算术平均数
    M2=M1.mean(axis=1)
    return M2

#法二：几何平均数
def Weight_By_G(M:np.array):
    n=M.shape[0]
    #按行相乘
    M1=np.prod(M,axis=1)
    #开n次方
    M2=M1**(1/n)
    #归一化
    M3=M2/M2.sum()
    return M3

#法三：特征向量法
def Weight_By_E(M:np.array):
    values,vectors=np.linalg.eig(M)
    pos=np.argmax(values)
    vector=vectors[:,pos].real
    V=vector/vector.sum()
    return V  #取特征向量实部

def Weight(M:np.array):
    V1=Weight_By_A(M)
    V2=Weight_By_G(M)
    V3=Weight_By_E(M)
    print(f'算术平均法计算权重：{V1}')
    print(f'几何平均法计算权重：{V2}')
    print(f'特征向量法计算权重：{V3}')
    return V3