精华内容
下载资源
问答
  • AHP层次分析法Python实现代码,如有需要,请大家下载!!!可用!!
  • 使用Python语言实现AHP算法,运行代码需预先安装numpy包,Python3以上版本
  • python实现AHP算法(层次分析法)

    千次阅读 2020-09-07 21:26:56
    层次分析法(Analytic Hierarchy Process,AHP)由美国运筹学家托马斯·塞蒂(T. L. Saaty)于20世纪70年代中期提出,用于确定评价模型中各评价因子/准则的权重,进一步选择最优方案。该方法仍具有较强的主观性,...

    一、层次分析法原理

    层次分析法(Analytic Hierarchy Process,AHP)由美国运筹学家托马斯·塞蒂(T. L. Saaty)于20世纪70年代中期提出,用于确定评价模型中各评价因子/准则的权重,进一步选择最优方案。该方法仍具有较强的主观性,判断/比较矩阵的构造在一定程度上是拍脑门决定的,一致性检验只是检验拍脑门有没有自相矛盾得太离谱。

    相关的理论参考可见wiki百科

    二、代码实现

    需要借助Python的numpy矩阵运算包,代码最后用了一个b1矩阵进行了调试,相关代码如下,具体的实现流程已经用详细的注释标明,各位小伙伴有疑问的欢迎留言和我一起讨论。

    import numpy as np
    class AHP:
        """
        相关信息的传入和准备
        """
    
        def __init__(self, array):
            ## 记录矩阵相关信息
            self.array = array
            ## 记录矩阵大小
            self.n = array.shape[0]
            # 初始化RI值,用于一致性检验
            self.RI_list = [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]
            # 矩阵的特征值和特征向量
            self.eig_val, self.eig_vector = np.linalg.eig(self.array)
            # 矩阵的最大特征值
            self.max_eig_val = np.max(self.eig_val)
            # 矩阵最大特征值对应的特征向量
            self.max_eig_vector = self.eig_vector[:, np.argmax(self.eig_val)].real
            # 矩阵的一致性指标CI
            self.CI_val = (self.max_eig_val - self.n) / (self.n - 1)
            # 矩阵的一致性比例CR
            self.CR_val = self.CI_val / (self.RI_list[self.n - 1])
    
        """
        一致性判断
        """
    
        def test_consist(self):
            # 打印矩阵的一致性指标CI和一致性比例CR
            print("判断矩阵的CI值为:" + str(self.CI_val))
            print("判断矩阵的CR值为:" + str(self.CR_val))
            # 进行一致性检验判断
            if self.n == 2:  # 当只有两个子因素的情况
                print("仅包含两个子因素,不存在一致性问题")
            else:
                if self.CR_val < 0.1:  # CR值小于0.1,可以通过一致性检验
                    print("判断矩阵的CR值为" + str(self.CR_val) + ",通过一致性检验")
                    return True
                else:  # CR值大于0.1, 一致性检验不通过
                    print("判断矩阵的CR值为" + str(self.CR_val) + "未通过一致性检验")
                    return False
    
        """
        算术平均法求权重
        """
    
        def cal_weight_by_arithmetic_method(self):
            # 求矩阵的每列的和
            col_sum = np.sum(self.array, axis=0)
            # 将判断矩阵按照列归一化
            array_normed = self.array / col_sum
            # 计算权重向量
            array_weight = np.sum(array_normed, axis=1) / self.n
            # 打印权重向量
            print("算术平均法计算得到的权重向量为:\n", array_weight)
            # 返回权重向量的值
            return array_weight
    
        """
        几何平均法求权重
        """
    
        def cal_weight__by_geometric_method(self):
            # 求矩阵的每列的积
            col_product = np.product(self.array, axis=0)
            # 将得到的积向量的每个分量进行开n次方
            array_power = np.power(col_product, 1 / self.n)
            # 将列向量归一化
            array_weight = array_power / np.sum(array_power)
            # 打印权重向量
            print("几何平均法计算得到的权重向量为:\n", array_weight)
            # 返回权重向量的值
            return array_weight
    
        """
        特征值法求权重
        """
    
        def cal_weight__by_eigenvalue_method(self):
            # 将矩阵最大特征值对应的特征向量进行归一化处理就得到了权重
            array_weight = self.max_eig_vector / np.sum(self.max_eig_vector)
            # 打印权重向量
            print("特征值法计算得到的权重向量为:\n", array_weight)
            # 返回权重向量的值
            return array_weight
    
    
    if __name__ == "__main__":
        # 给出判断矩阵
        b = np.array([[1, 1 / 3, 1 / 8], [3, 1, 1 / 3], [8, 3, 1]])
    
        # 算术平均法求权重
        weight1 = AHP(b).cal_weight_by_arithmetic_method()
        # 几何平均法求权重
        weight2 = AHP(b).cal_weight__by_geometric_method()
        # 特征值法求权重
        weight3 = AHP(b).cal_weight__by_eigenvalue_method()
    
    
    
    展开全文
  • 层次分析法AHPPython实现

    千次阅读 2020-05-01 22:52:51
    AHP (Analytic Hierarchy Process)层次分析法是一种实用的多方案或多目标的决策方法。 层次分析法是一种主客观结合的多指标综合评价方法;即定性分析与定量分析有机结合,实现定量化决策。 有两次定权过程,即...

    AHP (Analytic Hierarchy Process)层次分析法是一种实用的多方案或多目标的决策方法。

    1. 层次分析法是一种主客观结合的多指标综合评价方法;即定性分析与定量分析有机结合,实现定量化决策。

    2. 有两次定权过程,即准则层定权和方案层定权。

    思路

    层次分析法的思路是:
    将所要分析的问题层次化,根据问题的性质和要达到的总目标,将问题分解成不同的组成因素,按照因素间的相互关系及隶属关系,将因素按不同层次聚集组合,形成一个多层分析结构模型,最终归结为最低层(方案、措施、指标等)相对于最高层(总目标)相对重要程度的权值或相对优劣次序的问题。

    决策者用理论和实践经验去分别判断准则层、目标层内各个指标的相对重要程度,并合理地给出每个决策方案中每个指标的标准化权数,利用权数求出各方案的优劣次序,从而选择最优目标。

    步骤

    用AHP分析问题大体要经过以下五个步骤:
    (1) 建立层次结构模型;
    (2)构造判断矩阵;
    (3)层次单排序;
    (4)一致性检验;
    (5)层次总排序。
    其中后三个步骤在整个过程中需要逐层地进行。

    例如:

    (1) 建立层次结构模型

    假如现在一位同学在找工作时,同时收到三份offer,三家公司都非常不错,此时他很犹豫,不知道怎么选择。

    他想到了层次分析法,他现在的目标是选择最优的工作,考虑的因素有:待遇、晋升制度、进修机会、地理位置、社会声誉。因此,建立如下层次结构模型:
    在这里插入图片描述
    层次分析法的核心在于,如何合理解决各个指标的定权问题

    有两次定权过程,即准则层定权和方案层定权。

    (2)构造判断矩阵

    什么是判断矩阵?判断矩阵是建立指标之间两两比较的影响程度的矩阵。例如上述准则层的五个指标所构成的判断矩阵A:
    在这里插入图片描述
    如何依据决策者的理论和经验来构建判断矩阵呢?在实际评价中,如何对多个指标进行赋权,较为困难。但对两两指标之间的比较影响程度,决策者进行主观正确判断较为容易。

    在判断矩阵中,指标之间的比较影响程度赋值需要借助“标度”,标度如下所示:

    在这里插入图片描述

    对于要比较的因子而言,你认为一样重要就是1:1,强烈重要就是9:1,也可以取中间数值6:1等,两两比较,把数值填入,并排列成判断矩阵(判断矩阵是对角线积是1的正反矩阵即可)。
    在这里插入图片描述

    (3)检验判断矩阵的合理性

    判断矩阵构造完毕后,需要检验判断矩阵是否满足一致性。什么是矩阵一致性?矩阵一致性的定义为: a i j × a j k = a i k a_{ij}\times a_{jk}=a_{ik} aij×ajk=aik。例如待遇:晋升制度=3:1,晋升制度:进修机会=5:1,在一致性定义下,待遇:进修机会=15:1。显然,在判断矩阵的标度中,并没有设置大于9以上的标度。在检验判断矩阵合理性上,我们不是要矩阵严格满足一致性,而是满足A>B,B>C,那么A必然大于C,这样检验方式称为一致性检验。

    一致性检验是通过计算一致性比例CR得来:
    C R = C I R I CR=\frac{CI}{RI} CR=RICI

    其中CI表示一致性指标,其公式为
    C I = λ max ⁡ − 1 n − 1 CI=\frac{\lambda _{\max}-1}{n-1} CI=n1λmax1

    n表示判断矩阵中指标的个数, λ max ⁡ \lambda _{\max} λmax表示判断矩阵的最大特征值,

    RI表示随机一致性指标,可查表获得,如下表所示

    在这里插入图片描述

    当CR<0.1时,则表示一致性检验通过,判断矩阵构造合理,CI 越大,判断矩阵的不一致性程度越严重。
    因此,目前唯一未知数是判断矩阵的最大特征值。特征值的计算公式为:
    A W = λ W AW=\lambda W AW=λW

    其中W是最大特征值 λ max ⁡ \lambda _{\max} λmax对应的特征向量。

    求解可以通过软件,比如Excel,R语言,python,MATLAB等等

    (4)定权

    前述已知,AHP定权过程分为两个阶段,第一阶段是关于准则层的定权第二阶段是关于方案层的定权

    在定权方法上,有最小平方权法、特征值法、方根法、和积法等,常用定权方法为特征值法。

    • 对于准则层指标的定权,应用最大特征值所对应的特征向量,即
      W = ( w 1 , w 2 , w 3 , w 4 , w 5 ) T W=\left( w_1,w_2,w_3,w_4,w_5 \right) ^T W=(w1,w2,w3,w4,w5)T
      进行赋权,权重进行归一化处理,使得权和等于1。

    • 对于方案层指标的定权,需要构建每个准则层与三种方案的判断矩阵,检验判断矩阵的合理性,并计算其最大特征值所对应的特征向量。即:
      在这里插入图片描述
      可以看出,方案层所构造的判断矩阵有多个,对于方案层判断矩阵的一致性检验,采用总排序一致性比例,其公式为:
      C R = ∑ k W k C I k ∑ k W k R I k CR=\frac{\sum_k^{}{W_k}CI_k}{\sum_k^{}{W_kRI_k}} CR=kWkRIkkWkCIk
      其中k表示准则层的相应指标。

    通过对上述五个判断矩阵的计算,可以得到每个方案在每个准则层因素下的权重,即
    W 1 = ( w 11 , w 12 , w 13 ) T , W 2 = ( w 21 , w 22 , w 23 ) T W_1=\left( w_{11},w_{12},w_{13} \right) ^T,W_2=\left( w_{21},w_{22},w_{23} \right) ^T W1=(w11,w12,w13)T,W2=(w21,w22,w23)T
    W 3 = ( w 31 , w 32 , w 33 ) T , W 4 = ( w 41 , w 42 , w 3 ) T W_3=\left( w_{31},w_{32},w_{33} \right) ^T,W_4=\left( w_{41},w_{42},w_3 \right) ^T W3=(w31,w32,w33)T,W4=(w41,w42,w3)T
    W 5 = ( w 51 , w 52 , w 53 ) T , W_5=\left( w_{51},w_{52},w_{53} \right) ^T, W5=(w51,w52,w53)T,

    (5)排序

    经过上述计算,已经得到准则层、方案层中各个指标和方案的权重,如下表所示。
    在这里插入图片描述
    通过比较方案总排序权重的高低,即可对三份工作作出选择。

    Python实现代码

    这里请参见下面博客中代码,讲的很详细
    AHP(层次分析法)学习笔记及多层权重Python实践

    展开全文
  • 层次分析法(Analytic Hierarchy Process,AHP)由美国运筹学家托马斯·塞蒂(T. L. Saaty)于20世纪70年代中期提出,用于确定评价模型中各评价因子/准则的权重,进一步选择最优方案。该方法仍具有较强的主观性,...
  • Python实现AHP(层次分析法)

    万次阅读 多人点赞 2018-05-22 14:59:20
    import csv import numpy as np import tensorflow as tf from sklearn.preprocessing import MinMaxScaler from numpy import * ...class AHP: def __init__(self, array): self.row = len(array) ...
    import csv
    import numpy as np
    import tensorflow as tf
    from sklearn.preprocessing import MinMaxScaler
    from numpy import *
    
    class AHP:
        def __init__(self, array):
            self.row = len(array)
            self.col = len(array[0])
    
        def get_tezheng(self, array):# 获取特征值和特征向量
            te_val, te_vector = np.linalg.eig(array)
            list1 = list(te_val)
            print("特征值为:", te_val)
            print("特征向量为:", te_vector)
            # 得到最大特征值对应的特征向量
            max_val = np.max(list1)
            index = list1.index(max_val)
            max_vector = te_vector[:, index]
            print("最大的特征值:" + str(max_val) + "   对应的特征向量为:" + str(max_vector))
            return max_val, max_vector
    
        def RImatrix(self, n):  # 建立RI矩阵
            print(n)
            n1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
            n2 = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45]
            d = dict(zip(n1,n2))
            print("该矩阵在一致性检测时采用的RI值为:", d[n])
            return d[n]
    
        def test_consitstence(self, max_val, RI):  # 测试一致性
            CI = (max_val - self.row) / (self.row - 1)
            if RI == 0:
                print("判断矩阵的RI值为  " + str(0) + "  通过一致性检验")
                return True
            else:
                CR = CI / RI
                if CR < 0.10:
                    print("判断矩阵的CR值为  " + str(CR) + "  通过一致性检验")
                    return True
    
                else:
                    print("判断矩阵的CR值为  " + str(CR) + "  判断矩阵未通过一致性检验,请重新输入判断矩阵")
                    return False
    
    def main():
        weigh_matrix = []
        num_of_standard = []
        l0 = []
        l1 = []
    
        def input_data(f1):  # 对输入的判断矩阵进行处理
            l0 = []
            l1 = []
            li = []
            with open(f1) as f:
                reader = csv.reader(f)
                for line in reader:
                    print(line)
                    if line == []:
                        l1.append(l0)
                        l0 = []
                        continue
                    for i in line:
                        if "/" in i:
                            b = i.split("/")
                            li.append(int(b[0]) / float(b[1]))
                        else:
                            li.append(float(i))
                    l0.append(li)
                    li = []
                l1.append(l0)
            print(l1)
            return l1
        l1= input_data(r"C:\Users\adm\Desktop\data11.txt")
        print("l1",l1)
    
    
        def normalize_vector(max_vector):  # 特征向量归一化
            vector_after_normalization = []
            sum0 = np.sum(max_vector)
            for i in range(len(max_vector)):
                vector_after_normalization.append(max_vector[i] / sum0)
            print("该级指标的权重权重矩阵为:  " + str(vector_after_normalization))
    
            file = open(r"C:\Users\adm\Desktop\data000112.txt", 'a')
            for i in vector_after_normalization:
                file.write(str(i))
                file.write("\n")
    
            return vector_after_normalization
    
        def to_input_matrix():#判别矩阵的一致性检验
             for i in l1:
                length = len(l1)
                print(i)
                a = AHP(i)
                max_val, max_vector = a.get_tezheng(i)
                record_max_vector = max_vector
                RI = a.RImatrix(len(i))
                flag = a.test_consitstence(max_val, RI)
                while not flag:
                    print("对比矩阵未通过一致性检验,请重新输入对比矩阵!")
                    break
                    #flag = to_input_matrix(length)
                weight = normalize_vector(record_max_vector)  # 返回权重[[0.5, 0.5], [0.5, 0.5], [0.5, 0.5]]
                weigh_matrix.append(weight)
             print("最终的权重矩阵为:", weigh_matrix)
             return weigh_matrix
        w00=to_input_matrix()
        print("w00",w00)
        def construct_weightmatrix(weight):
            data = []
            l = []
            for i in weight[0]:
                data.append(i.real)
            #print(data)
    
            for i in weight[1:4]:
                for j in i:
                    data.append(j.real)
    
            for i in weight[4:]:
                for j in i:
                    data.append(j.real)
            print(data)
            data2 = data
            print(len(data2))
            return data2
        d = construct_weightmatrix(w00)
        print(d)
    
        def get_index(data ):  # 第一个矩阵1*3,第二个矩阵7*3。第三个矩阵16*7
            row = [3, 7, 16]
            column = [1, 3, 7]
    
            x1 = [0, 1, 2]
            y1 = [0, 0, 0]
    
            x2 = [0, 1, 2, 3, 4, 5, 6]
            y2 = [0, 0, 1, 1, 1, 2, 2]
    
            x3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, ]
            y3 = [0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6]
            weight = []
    
            def transform(x, y, data, row, col):
                h = list(zip(x, y))
                print(h)
                mat1 = zeros((row, col))
                for i in range(len(data)):
                    mat1[h[i]] = data[i]
                weight.append(mat1)
                print(weight)
    
            transform(x1, y1, data[:3], 3, 1)
            transform(x2, y2, data[3:10], 7, 3)
            transform(x3, y3, data[10:], 16, 7)
            return weight
        w1 = get_index(d)#返回组织好的权重矩阵d
        for i in w1:
            print(i)
            # print(w1)
    
        def get_finalweight(w):#矩阵相乘
            j = 0
            s = np.array([1])
            print(np.dot(w[1], w[0]))
    
            while j < len(w):
                print("weight0[i]", w[j])
                s = np.dot(w[j], s)
                print("s", s)
                j += 1
            print("s", s)
            return s
    
        s1=get_finalweight(w1)
    
        def data_process():
            i = 0
            data = []
            global name
            name = []
            with open(r'C:\Users\adm\Desktop\数据.csv') as f:
                reader = csv.reader(f)
                for row in reader:
                    if i == 0:
                        i += 1
                        continue
                    else:
                        data.append(row[:])
                        name.append(row[1])
    
            data = np.asarray(data)
            data1 = data[:, 3:].astype('float64')
            scaler = MinMaxScaler(feature_range=(0, 1))
            data1 = scaler.fit_transform(data1)
            print(len(data1))
            return data1
    
        def ScoreCalculator():
            SCORE = []
            score = []
            value = data_process()
            print(len(value))
            for i in range(len(value)):
                #print("i",len(value[i]))
                #print(len(s1))
                SCORE = np.sum([x * y for x, y in zip(value[i], s1)]) * 100
                score.append(SCORE)
            score = [i / np.max(score) * 100 for i in score]
            print(score)
    
            d = dict(zip(name, score))
            d1 = sorted(d.items(), key=lambda items: items[1], reverse=True)
            # print(d1)
            for key, value in d1[:80]:
    
                if value > 80:
                    print(str(key) + "  最终得到的评分为: " + str(value) + "    合理")
                elif 70 < value < 80:
                    print(str(key) + "  最终得到的评分为: " + str(value) + "    较为合理")
                elif 60 < value < 70:
                    print(str(key) + "  最终得到的评分为: " + str(value) + "    一般合理")
                else:
                    print(str(key) + "  最终得到的评分为: " + str(value) + "    不合理")
    
            print("所有指标权重的和", np.sum(s1))
        ScoreCalculator()
    
    if __name__ == "__main__":
        main()
    展开全文
  • 主成分分析法,AHP-promethee
  • 实际生活中,往往有一些很复杂的系统,...AHP可以帮助你。(请忽略现在的选举都是投票这个现实) 层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、...

    实际生活中,往往有一些很复杂的系统,我们没办法直观草率的确定权重,比如甲、乙、丙三人竞选总统,严谨的说,需要从三人的社交能力、管理能力、经济能力等方面来考虑,在每个方面,三位候选人的得分也不同,那么到底怎么来判断这三个人的综合得分呢?AHP可以帮助你。(请忽略现在的选举都是投票这个现实)

    层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、约束)的若干层次,通过定性指标模糊量化方法算出层次单排序(权数)和总排序,以作为目标(多指标)、多方案优化决策的系统方法。

    层次分析法是将决策问题按总目标、各层子目标、评价准则直至具体的备投方案的顺序分解为不同的层次结构,然后用求解判断矩阵特征向量的办法,求得每一层次的各元素对上一层次某元素的优先权重,最后再加权和的方法递阶归并各备择方案对总目标的最终权重,此最终权重最大者即为最优方案。

    层次分析法比较适合于具有分层交错评价指标的目标系统,而且目标值又难于定量描述的决策问题。

     

    下面是代码:

    因为注释较多,根本无需一步一步的详解就能看懂,所以就一下子全放上来了。

    #思路:
    #1.首先输入每个指标下面对应的判断矩阵,
    #该矩阵中的值是通过大数据(或者专家)得到的每两个指标之间的相对重要程度值,
    #通过AHP计算这些判断矩阵是否通过一致性的检验,通过即合理,
    #不通过就说明矩阵中的两指标间的相对重要程度有过分矛盾的地方,
    
    import csv
    import numpy as np
    import tensorflow as tf
    
    #定义一个叫AHP的类
    class AHP:
        def __init__(self,array):#array是每个指标下面对应的判断矩阵,即原始数据
            self.row = len(array)#计算矩阵的行数
            self.col = len(array[0])#计算矩阵的列数
        def get_tezheng(self,array):#获取最大特征值和对应的特征向量
                te_val ,te_vector = np.linalg.eig(array)#numpy.linalg.eig() 计算矩阵特征值与特征向量
                list1=list(te_val)#te_val是一个一行三列的矩阵,此处将矩阵转化为列表
                print("特征值为:",te_val)
                print("特征向量为:",te_vector)
    			
                #得到最大特征值对应的特征向量
                max_val = np.max(list1)#最大特征值
                index = list1.index(max_val)#最大特征值在列表中的位置
                max_vector = te_vector[:,index]#通过位置来确定最大特征值对应的特征向量
                print("最大的特征值:"+str(max_val)+"   对应的特征向量为:"+str(max_vector))
                return max_val,max_vector    
        
        def RImatrix(self,n):#建立RI矩阵,该矩阵是AHP中自带的,类似标杆一样,除n之外的值不能更改
                d = {}
                n1 = [1,2,3,4,5,6,7,8,9]
                n2 = [0,0,0.58,0.90,1.12,1.24,1.32,1.41,1.45]
                for i in range(n):#获取n阶矩阵对应的RI值
                    d[n1[n]] = n2[n]
                print("该矩阵在一致性检测时采用的RI值为:",d[n1[n]])
                return d[n1[n]]
                       
        def test_consitstence(self,max_val,RI): #测试一致性,AHP中最重要的一步,用于检验判断矩阵中的数据是否自相矛盾
                CI = (max_val-self.row)/(self.row-1) #AHP中计算CI的标准公式
                CR = CI/RI #AHP中计算CR的标准公式
                if  CR < 0.10 :
                    print("判断矩阵的CR值为  " +str(CR) + "通过一致性检验")
                    return True
                else:
                    print("判断矩阵的CR值为  " +str(CR) + "判断矩阵未通过一致性检验,请重新输入判断矩阵")
                    return False  
                
        def normalize_vector(self,max_vector):#特征向量归一化
                vector_after_normalization=[]#生成一个空白列表,用于存放归一化之后的特征向量的值
                sum0 = np.sum(max_vector)#将特征向量的每一个元素相加取和
                for i in range(len(max_vector)):
                    #将特征向量的每一个元素除以和,得到比值,保证向量的每一个元素都在0和1之间,直线归一化
    				#将归一化之后的元素依次插入空白列表的尾部
    				vector_after_normalization.append(max_vector[i]/sum0)
                print("该级指标的权重矩阵为:  "+str(vector_after_normalization))
                return vector_after_normalization 
            
        def weightCalculator(self, normalMatrix):#计算最终指标对应的权重值
            #layers weight calculations.
            listlen = len(normalMatrix) -1 #设置listlen的初始值为normalMatrix最后一个元素的index
            layerWeights = list()#空白权重列表
            while listlen > -1:
                sum = float()#sum的初始值为0.0,并且限制了sum的类型为浮点型
                for i in normalMatrix:
                    sum+= i[listlen]  #求normalMatrix各元素的和
                sumAverage = round(sum / len(normalMatrix),3)#求normalMatrix各元素的平均值,并保留三位小数
                layerWeights.append(sumAverage)#为什么平均值是权重??????
                listlen-=1
            return layerWeights
    
    		
    import csv
    import numpy as np
    import tensorflow as tf
    
    def main():#这里需要确定指标的规模即多少个一级指标,多少个二级指标,这样才能确定要计算多少个对比矩阵
        array1=[]
        array2=[]
        def define_structure():#构造AHP的层次结构
            level_structure = []       
            level = int(input("请输入指标的级数:"))#输入比如说这是个三级指标体系
            level0 = input("请输入每一级下指标的个数:")
            level.append(level0)#将列表level0作为一个元素插入到列表level的末尾
            level2 = []
            for i in range(level):#每一级指标下有多少具体的指标个数
                rate_num = input("请输入" +str(i)+ "层下指标的个数:")
                #level2.append(rate_num)
                for j in range(rate_num ):
                    two_level_for_one = int(input("请输入第" +str(i)+ " 个一级指标对应的下级指标的个数:"))
                    level_structure.append(two_level_for_one )
            return level_structure
        
        
        def creat_matrix(n):
            n = define_structure()
            for i in n:
                length = input("请输入指标对比矩阵的阶数:")#对应指标下共有多少个相互对比的对象
                length = int(length)#向下取整,若length=3.7,则int(length)=3
                count=0
            for i in  range(length):#若length=3,则这部分实现的是,输入矩阵中3*3=9个元素的值
                for j in range(length):
                    count += 1
                    x = input("请输入指标对比矩阵的第"+str(count)+ " 个元素:")
                    x = float(x)
                    array1.append(x)#此时的array1还不是一个矩阵,只是包含9个元素的列表
    				#eg:array1=[4,7,8,2,1,13,16,5,11]
            for i in range(length*length):#将列表array1矩阵化
                if (i+1)%length==0:#使用i+1是为了避免i=0的情况,因为0%3==0是true
                    array2.append(array1[i-length+1:i+1])#每3个元素形成一个列表插入到array2的末尾
            print(array2)#eg:array2=[[4,7,8],[2,1,13],[16,5,11]]矩阵形式
            
        array2=np.mat(array2)#NumPy函数库中的matrix与MATLAB中matrices等价,由于AHP是比较数学的东西,所以习惯的mat一下矩阵
        a=AHP(array2)
        max_val,max_vector = a.get_tezheng(array2)#获取最大特征值和对应的特征向量
        RI= a.RImatrix(length)#获取length阶矩阵对应的RI值
        flag = a.test_consitstence(max_val,RI)#测试一致性,返回TRUE或者flase
        if flag:#如果flag=TRUE,则调用函数通过最大特征值对应的特征向量获取权重矩阵
            weight = a.normalize_vector(max_vector)
      
        
    main()

    可以拷贝到本地慢慢消化,相信如此完备的注释会大大的有助于您的学习。

    此代码为多年前的代码了,最近重新运行一遍,竟然报错了,不知哪里的问题,还望有经验的大神指正。

     

     

    展开全文
  • import numpy as np # Python本身没有处理矩阵的数据类型,因此需要使用附加的函数库。 """ 1. 读取csv文件 """ def prin(path): tmp = np.loadtxt(path, dtype=np.str, delimiter=",") tmp = tmp.astype(float) # ...
  • python实现层次分析法(AHP) 层次分析法是数学建模的入门算法,类似于算法竞赛中的cout<<"Hello,world!"<<endl; 对于python数据分析的初学者来说,在使用python实现层次分析法时,难点是特征值法的...
  • 层次分析法(The analytic hierarchy process)简称AHP,它是将与决策有关的因素分解成目标、准则、方案等层次,在此基础之上进行定性和定量分析的决策方法。...本文为简明AHP学习笔记,并通过Python实践构建多层权重。
  • 鉴于Python成熟、方便的矩阵操作,先用Python简单复现一下该算法。 1 理论基础 关于AHP层次分析法的材料很多,可以自行查阅,推荐参考文献《高可用集群系统关键技术的研究与实现》第4.2和4.3节关于层次分析法的理论...
  • AHP | 层次分析法原理及Python实现

    千次阅读 多人点赞 2020-02-25 11:32:51
    层次分析法(Analytic Hierarchy Process,AHP)由美国运筹学家托马斯·塞蒂(T. L. Saaty)于20世纪70年代中期提出,用于确定评价模型中各评价因子/准则的权重,进一步选择最优方案。该方法仍具有较强的主观性,...
  • AHP(层次分析法)的全面讲解及python实现

    千次阅读 多人点赞 2020-05-09 13:58:30
    0.398*0.593+0.218*0.123+0.085*0.087+0.299*0.265=0.349 方案 B(最优):0.398*0.341+0.218*0.320+0.085*0.274+0.299*0.655=0.425 方案 C:0.398*0.066+0.218*0.557+0.085*0.639+0.299*0.080=0.226 三、python完整...
  • AHP经常出现在数学建模里面,同学们可以看看,直接调用get_weight函数就能得到权重,挺方便的。 大创是个好东西,建议参加,我们这个论文因为赶时间没能好好搞,建议立项后早完成,别立项了就不管了。 开源了算法,...
  • def AHP(A) -> np.array: # 平均随机一致性指标。 RI_dict = {1: 0, 2: 0, 3: 0.58, 4: 0.90, 5: 1.12, 6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45, 10: 1.49} n = len(A) for i in range(1, n): for k in range(i...
  • AHP】层次分析法原理与Python实现

    千次阅读 多人点赞 2020-01-07 17:46:41
    层次分析法,简称AHP,层次分析法是 多目标决策问题 的一个解决方案。 它把有关的元素分解成目标、准则、方案等层次,在此基础之上进行定性和定量分析的决策方法。 该方法是美国运筹学家匹茨堡大学教授萨蒂于20世纪...
  • import numpy as np A = np.array([[1, 2, 3], [1/2, 1, 2], [1/3, 1/2, 1]]) m=len(A) #获取指标个数 n=len(A[0]) RI=[0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49...
  • 层次分析法(Analytic Hierarchy Process,AHP):是一种定性和定量相结合的、系统的、层次化的分析方法。 这种方法的特点就是在对复杂决策问题的本质、影响因素及其内在关系等进行深入研究的基础上,利用较少的定量...
  • AHP及EWM的python实现

    2021-11-28 14:03:59
    一、AHP A为对比矩阵 def AHP(A) -> np.array: # 平均随机一致性指标。 RI_dict = {1: 0, 2: 0, 3: 0.58, 4: 0.90, 5: 1.12, 6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45, 10: 1.49} n = len(A) for i in range(1, n...
  • 机器学习 | AHP层次分析法

    千次阅读 多人点赞 2019-05-15 20:39:47
    3 AHP层次分析法的实现3.1 步骤3.2 实际的例子3.2.1 背景3.2.2 Step1 构建层次结构模型3.2.3 Step2 构造成对比较矩阵3.2.4 Step3 一致性检验3.2.5 Step4 确定权重和最优方案3.3 Python实现3.3.1 直接将打分ok的excel...
  • 所存在的指标权重由专家根据经验给出带来的主观性等问题,采用层次分析法与模糊综合评判法相结合对煤矿重大危险源安全指标体系进行优化,构建了一种新的煤矿重大危险源安全评价方法,即AHP-FCE法。并利用湖南省60家煤矿...
  • 层次分析法(AHP).py

    2019-05-16 11:34:42
    层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、约束)的若干层次,通过定性指标模糊量化方法算出层次单排序(权数)和总排序,以作为目标(多指标...
  • python层次分析法.py

    2019-09-20 16:22:50
    层次分析法代码,可以通过该代码进行适当改变,针对自己的问题进行层次分析,采用python
  • python层次分析 前言 (Preface) Through the course of a lifetime, a human makes a number of decisions, ranging from the most trivial ones that have almost no impact, to those that have life changing ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 402
精华内容 160
关键字:

ahppython

python 订阅