AHP层次分析法

AHP层次分析法是一种层次权重决策分析法，解决多目标复杂问题的定性和定量的决策分析方法，用决策者的的经验判定各个衡量目标之间相对的重要程度，给出每个决策方案的权重，确定优先次序。

1、基本原理

消费者对包包的偏好

image.png

这是最简单的层次分析。

2、解决思路

我们的基本思路是将所要分析的问题层次化，把影响目标的因素分解成不同的因素，按照因素的关联关系和隶属关系形成不同的组合，这样就形成了一个多层次分析模型，并对比优劣。

3、层次分析模型的步骤

• 1、创建层次目标
• 2、设置分析法的标准（考虑的因素）
• 3、设置分析法的子标准（考虑因素的子因素，可加可不加）
• 4、设置方案层
• 5、逐层矩阵计算，验证归一性
• 6、最终得出权重占比

层次分析法所要解决的问题是关于最低层对最高层的相对权重的问题，按此相对权重可以对最低层中的各种方案、措施进行排序，从而在不同的方案中做出选择或形成选择方案的原则.

构建判断矩阵：

我们在构建矩阵的时候必须保持一致性，我们将因素两两比较的。

矩阵aij的评分标准，下面是9分标准，也可以设置5分标准、7分标准

注意：
我们在设置aij的评分的同时，aji的评分是aij评分的倒数，假如a12的评分是2，那个a21的评分是1/2

一致性验证：

我们得出求出矩阵的特征向量W和特征值λ之后，我们需要判断矩阵是否一致性标准。

定义一致性指标 CI=λ−n/n-1；
CI越接近0，表示一致性越好，越大表示一致性月差。
为了衡量CI的发小，我们引入随机一直项指标RI

定义一致性比率CR= CI/RI,当CR<0.1的时候我们就认为满足一致性校验，否则我们就需要重新对比矩阵，对其中的评分重新调整.

实例：

我们构建准则层对目标层的矩阵：

准则矩阵.png

计算特征向量的过程（计算权重占比的过程）：
1、列向求和

列向求和.png

image.png

得到列向归一化矩阵：

列向归一化矩阵.png

行求和

image.png

AW.png

得出AW的值便可以得出λ，此时λ,存在3个值，我们去其算数平均数
λ=（0.3692/0.1226+0.9684/0.3202+1.6879/0.5571）/3 = 3.0219
CI = λ-n/n-1= 0.01095
CR = CI/RI = 0.0189 < 0.1 所以符合一致性
通过上面的层次分析，我们得出评价是最重要的因素，影响消费者对包包的购买。

层次总排序以及一次性检验

• 计算某一层次对总目标相当于重要性的权值，称为层次总排序
• 这一过程是从最高层次到最低层次依次进行。

image.png

A层m个因素A1,A2,⋅⋅⋅,Am, ,对总目标Z的排序为a1,a2,⋅⋅⋅,am
B层n个因素对上层A中因素为Aj的层次单排序为b1j,b2j,⋅⋅⋅,bnj(j=1,2,3,⋅⋅⋅,m)

层次总排序的一致性比例
CR=(a1CI1+a2CI2+...+amCIm)/(a1RI1+a2RI2+...+amRIm),当CR<0.1的时候，我们认为层次总排序一致。

例子：
我们在上面选择包包的时候，我们第二层准则对目标的权向量W1=W=(0.1226，0.3202，0.5571)T，同样我们要求第三层对第二层每一个元素(准则)的权向量。

我们可以计算出

Bλ1= 3.0536      Bλ2 =3.0385      Bλ3 = 3.0037
BW1 = (0.7089,0.1786,0.1125)T
BW2 = (0.6370,0.2583,0.1047)T
BW3 = (0.5816,0.3090,0.1095)T

组合权向量

我们得到最终的矩阵权值：

RI = 0.58 ，我们可以验证CI<0.1,符合一致性检验

方案层对目标组合最终的权值向量是:(0.6149,0.2767,0.1083)T
所以我们可以得到LV包包是用户更关心的商品。

最终结果，我们将5-10人的评分结果都求取取来，然后去除最高和最低值，求每个解决方案的算数平均数，我们可以得到最终的解决方案。

我们在标准层的下方，继续写子标准，例如颜色分成红、黑、橙3中，我们求取去特征向量W，之后就能求出每个颜色是消费者最喜欢的，方法类似上面的流程。

python 代码：

# coding=UTF-8
import numpy as np
'''
@Description:求解矩阵的权向量
@para:成对比较矩阵
@return:权向量
'''
def abhWeightVector(Mat):
    sizeMat = Mat.shape[0]
    #print(Mat)
    #print(sizeMat)

    # 计算矩阵A的特征值，特征向量
    eigenvalueMat, eigenvectorMat = np.linalg.eig(Mat)
    #print("特征值：", eigenvalueMat)
    #print("特征向量：", eigenvectorMat)
    
    # 将所有特征值取绝对值
    absEigenvalueMat = map(abs, eigenvalueMat)
    absEigenvalueMat = list(absEigenvalueMat)  
    #print(absEigenvalueMat)
    
    # 绝对值最大的特征值
    maxEigenvalueMat = max(absEigenvalueMat)
    #print("绝对值最大的特征值：", maxEigenvalueMat)
    
    # 绝对值最大的特征值的索引
    maxEigenvalueIndexMat = absEigenvalueMat.index(maxEigenvalueMat)
    #print(maxEigenvalueIndexMat)
    
    # 绝对值最大的特征值对应的特征向量
    maxEigenvectorMat = eigenvectorMat[:, maxEigenvalueIndexMat]
    #print("绝对值最大的特征值对应的特征向量：", maxEigenvectorMat)
    
    # 将上述特征向量标准化，即权向量   
    standardizeVectorMat = list(map(abs, maxEigenvectorMat)) / sum(list(map(abs, maxEigenvectorMat)))
    #print(standardizeVectorMat)
    
    # 计算不一致程度CI
    CI = (maxEigenvalueMat - sizeMat) / (sizeMat - 1)
    #print(CI)
    
    # 平均随机一致性指标RI
    listRI = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45]
    
    #计算随机一致性比率
    CR = CI / listRI[sizeMat - 1]
    #print(CR)
    
    return standardizeVectorMat
   

MatA = np.array([[1, 2, 7, 5 ,5],
                 [1/2, 1, 4, 3, 3],
                 [1/7, 1/4, 1, 1/2, 1/2],
                 [1/5, 1/3, 2, 1, 1],
                 [1/5, 1/3, 3, 1, 1]])
standardizeVectorMatA = abhWeightVector(MatA)
print(standardizeVectorMatA)

MatB1 = np.array([[1, 1/3, 1/8],
                  [3, 1, 1/3],
                  [8, 3, 1]])
standardizeVectorMatB1 = abhWeightVector(MatB1)
print(standardizeVectorMatB1)

MatB2 = np.array([[1, 2, 5],
                  [1/2, 1, 2],
                  [1/5, 1/2, 1]])
standardizeVectorMatB2 = abhWeightVector(MatB2)
print(standardizeVectorMatB2)

MatB3 = np.array([[1, 1, 3],
                  [1, 1, 3],
                  [1/3, 1/3, 1]])
standardizeVectorMatB3 = abhWeightVector(MatB3)
print(standardizeVectorMatB3)

MatB4 = np.array([[1, 3, 4],
                  [1/3, 1, 1],
                  [1/4, 1, 1]])
standardizeVectorMatB4 = abhWeightVector(MatB4)
print(standardizeVectorMatB4)

MatB5 = np.array([[1, 4, 1/4],
                  [1, 1, 1/4],
                  [4, 1, 1]])
standardizeVectorMatB5 = abhWeightVector(MatB5)
print(standardizeVectorMatB5)

MatB = np.array([standardizeVectorMatB1, 
                 standardizeVectorMatB2, 
                 standardizeVectorMatB3, 
                 standardizeVectorMatB4, 
                 standardizeVectorMatB5])
print(MatB)

sumY1 = 0
sumY2 = 0
sumY3 = 0
for i in range(0, MatA.shape[0]):
    sumY1 += standardizeVectorMatA[i] * MatB[i][0]
    sumY2 += standardizeVectorMatA[i] * MatB[i][1]
    sumY3 += standardizeVectorMatA[i] * MatB[i][2]
    
sumY = [sumY1, sumY2, sumY3]
print(sumY)
maxY = max(sumY)
theBestIndex = sumY.index(maxY)
print(theBestIndex)

在线工具避免个人计算：
wis-ai
spssau

参考Blog:
层次分析法（AHP）详细步骤