1.问题的提出

日常生活中有很多的决策问题。决策是指在面临多种方案时需要依据一定的标准选择某一种方案。日常生活中有许多决策的问题。比如：

• 买钢笔，一般要依据质量、颜色、实用性、价格、外形等方面的因素选择某一支钢笔。
• 假期旅游，是去风光秀丽的苏州，还是去迷人的北戴河，或者是去山水甲天下的桂林，那一般会依据景色、费用、食宿条件、旅途等因素来算着去哪个地方。

面临各种各样的方案，要进行比较、判断、评价、直至最后的决策。这个过程中都是一些 主观的因素，这些因素可能由于个人情况的不同，有相应不同的比重，所以这样主观因素给数学方法的解决带来了很多的不便。

2.AHP

简单介绍一下什么是AHP？

层次分析法，简称AHP，它是一种 运筹学理论 。是指将与决策总是有关的元素分解成 目标、准则、方案 等层次，在此基础之上进行定性和定量分析的决策方法。

“该方法是美国运筹学家匹茨堡大学教授萨蒂于20世纪70年代初，在为美国国防部研究”根据各个工业部门对国家福利的贡献大小而进行电力分配”课题时，应用网络系统理论和多目标综合评价方法，提出的一种 层次权重决策分析方法。”

层次分析法(Analytic Hierarchy Process,AHP)这是一种定性和定量相结合的、系统的、层次化的分析方法。这种方法的特点就是在对复杂决策问题的本质、影响因素及其内在关系等进行深入研究的基础上，利用较少的定量信息使决策的思维过程数学化，从而为多目标、多准则或无结构特性的复杂决策问题提供简便的决策方法。是对难以完全定量的复杂系统做出决策的模型和方法。

层次分析法的原理，层次分析法根据问题的性质和要达到的总目标，将问题分解为不同的组成因素，并按照因素间的相互关联影响以及隶属关系将因素按不同的层次聚集组合，形成一个多层次的分析结构模型，从而最终 使问题归结为最低层(供决策的方案、措施等)相对于最高层(总目标)的相对重要权值的确定或相对优劣次序的排定。

所以，AHP理论本质是通过把一个复杂的问题拆解为多个目标或准则，并且通过定性量化的方式为每个目标进行赋权的一个过程。

简单来说AHP就是拆解加赋权，下面详细讲一下过程。
层次分析法的步骤，运用层次分析法构造系统模型时，大体可以分为以下四个步骤：

• 建立层次结构模型；
• 构造判断(成对比较)矩阵；
• 层次单排序及其一致性检验；
• 层次总排序及其一致性检验；

3.层次分析法的基本步骤

将决策的目标、考虑的因素(决策准则)和决策对象按他们之间的相互关系分成最高层、中间层和最低层，绘制层次结构图。

1.最高层(目标层)：决策的目的、要解决的问题；
2.中间层(准则层或指标层)：考虑的因素、决策的准则；
3.最低层(方案层)：决策时的备选方案；

3.1 建立层次结构模型

3.2 构造判断矩阵

什么是判断矩阵？

判断矩阵就是以参与指标计算的所有ferture组成的一个方阵，并且给出两两“比较量化值”。举例如下：

对于A和B两个因子，1表示：A和B一样重要；3表示：A比B重要一些；5表示：A比B重要；7表示：A比B重要的多；9表示：A比B极其重要，具体标准如下图所示：

因素i比因素j	量化值
同等重要	1
稍微重要	3
较强重要	5
强烈重要	7
极端重要	9
l两相邻判断的中间值	2，4，6，8

这其实就是一个典型的小组投票的过程，通过在方阵行列元素的两两比较，最终可以生成一个判断矩阵。比如对于有 A,B,C,D四个feature（分别代表钱，人员，时间，其它） 的判断矩阵如下图所示：

	A	B	C	D
A	1.00	2.00	5.00	4.00
B	0.50	1.00	1.67	1.33
C	0.20	0.60	1.00	0.80
D	0.25	0.75	1.25	1.00

3.3 层次单排序及一致性检验

所谓一致性校验是指在进行投票的时候的公平性和一致性。
比如你认为A比B重要，B比C重要，但是从最后的结果来看是C比A重要，这样即为不一致。
一致性校验是通过计算校验系数来实现的，通常用CR来表示，小于0.1即表示一致性校验通过。

CR包含一致性指标（CI）和随机一致性指标（RI）两部分，CR=CI/RI。

CI和RI是一个固定值，与矩阵的阶数有关。
一致性校验是通过计算校验系数来实现的，通常用CR来表示，小于0.1即表示一致性校验通过。

1.模拟
用EXCEL来进行计算（这里用三个参数来模拟）

构建判断矩阵A(正交矩阵)，用aij表示第i个因素相对于第j个因素的比较结果：

2.计算权重：
将矩阵A的各行向量进行几何平均(方根法)，然后进行归一化，即得到各评价指标权重和特征向量W：

3.一致性检验：

这里的n是指矩阵的维度

• CI = 0，有完全的一致性；
• CI 接近于0，有满意的一致性；
• CI越大，不一致越严重；
  为了衡量 CI的大小，引入随机一致性指标 RI。方法为随机构造500个成对比较矩阵

定义一致性比率：

RI系数如下表格

矩阵阶数	3	4	5	6	7	8	9	10	11
RI	0.5149	0.8931	1.1185	1.2494	1.3450	1.4200	1.4646	1.49	1.51

一般，当一致性比率CR < 0.1 时，认为A的不一致程度在容许的范围之内，有满意的一致性，通过一致性检验，可用其归一化特征向量作为权向量，否则要重新构造成对比较矩阵A，对 其 加以调整。

4.计算公式
各列键入公式：

按行相乘：F3=PRODUCT(C3:E3)，下拉至F5。

开n次方：G3=POWER(F3,1/3)，下拉至G5；G6=SUM(G3:G5)。

权重wi：H3=G3/G$6，下拉至H5。

AWi：I3=C3H$3+D3H$4+E3*H$5，下拉至I5。

AWi/wi：J3=I3/H3，下拉至J5；J6=AVERAGE(J3:J5)。

CI：K3=(J6-3)/2。

CR：L3=K3/0.5149

5.进行计算

6.结束
通过进行小组投票和自动计算，最终CR的值为0.03706，因此一致性检验通过。

权重Wi列即为每个feature的权重，因此最终我们可以得出该指标的计算公式为：

target = A * 0.1047 + B * 0.6369 + c * 0.2582

完美解决！

4.总结

大家这里或许会有个疑问：

采用AHP的方法进行赋权，小组投票阶段是主观判断重要性的，所以是不是会带来误差？

会，一定会。

不过 策略一定是建立在业务之上的，撇开业务谈策略都是伪策略。

采用AHP模型进行多因子赋权，

需要对该业务有足够的了解，更需要对该target下的多个feature有 足够的了解 ，哪个对于target的贡献度是最大的。

比如对于一个商品，什么样的商品是用户喜欢的？用户喜欢的商品有哪些feature？每个feature对于用户喜欢的贡献程度是什么样的？这些都是需要业务经验参与的。

如果说科学的方法都有一个前提假设，那么AHP也有一个前提，就是 先了解业务，再谈策略。

以上，希望能帮助到大家。

本公众号分享自己从程序员小白到经历春招秋招斩获10几个offer的面试笔试经验，其中包括【Java】、【操作系统】、【计算机网络】、【设计模式】、【数据结构与算法】、【大厂面经】、【数据库】期待你加入！！！

1.计算机网络----三次握手四次挥手
2.梦想成真-----项目自我介绍
3.你们要的设计模式来了
4.震惊！来看《这份程序员面试手册》！！！
5.一字一句教你面试“个人简介”
6.接近30场面试分享
7.你们要的免费书来了

层次分析法概述

定义

本文所有图片均来自本人的OneNote笔记

步骤归纳

例子

1. 建立层次结构模型
   

2. 构造判断(成对比较)矩阵
   
   
   第二层A的各个因素对目标层Z的成对比较矩阵（专家打分法）
   
   说明C2的重要性是C1的两倍
   第三层B的各个因素A1，A2……A5的成对比较矩阵分别如下：
   

3. 层次单排序及其一致性检验
   
   
   
   
   
   
   
   
   
   
   
   0.6=1/（1+1/2+1/6） 矩阵中其他数值同理
   0.587=1/3（0.6+0.615+0.545）

4. 层次单排序及其一致性检验
   
   
   
   
   
   

应用实例

Python实现

程序如下：

（本程序配的案例，现在是机密，先不能公开，但看程序仍可以理解）

import numpy as np

# A--D的判断矩阵
A_D = np.array([
    [1, 2, 6, 4],
    [1 / 2, 1, 5, 2],
    [1 / 6, 1 / 5, 1, 1 / 2],
    [1 / 4, 1 / 2, 2, 1]
])
# A1-A4的判断矩阵
A1_A4 = np.array([
    [1, 4, 5, 4],
    [1 / 4, 1, 4, 2],
    [1 / 5, 1 / 4, 1, 1 / 3],
    [1 / 4, 1 / 2, 3, 1]
])
# B1-B3的判断矩阵
B1_B3 = np.array([
    [1, 2, 3],
    [1 / 2, 1, 3],
    [1 / 3, 1 / 3, 1]
])
# C1--C2
C1_C2 = np.array([
    [1, 2],
    [1 / 2, 1]
])
# D1--D2
D1_D2 = np.array([
    [1, 1],
    [1, 1]
])
# A11_A14的判断矩阵
A11_A14 = np.array([
    [1, 1 / 5, 1 / 4, 1 / 2],
    [5, 1, 2, 3],
    [4, 1 / 2, 1, 2],
    [2, 1 / 3, 1 / 2, 1]
])
# A1的评价矩阵
A1_Emat = np.array([
    [0.109, 0.176, 0.142, 0.302, 0.27],
    [0.077, 0.062, 0.145, 0.324, 0.392],
    [0.057, 0.118, 0.159, 0.34, 0.327],
    [0.074, 0.173, 0.221, 0.402, 0.131]
])
# A21--A22
A21_A22 = np.array([
    [1, 1 / 2],
    [2, 1]
])
# A2的评价矩阵
A2_Emat = np.array([
    [0.182, 0.198, 0.245, 0.265, 0.11],
    [0.133, 0.147, 0.126, 0.318, 0.276]
])

# A31--A33
A31_A33 = np.array([
    [1, 2, 1],
    [1 / 2, 1, 1 / 2],
    [1, 2, 1]
])
# A3的评价矩阵
A3_Emat = np.array([
    [0.088, 0.206, 0.234, 0.265, 0.207],
    [0.093, 0.129, 0.25, 0.34, 0.188],
    [0.007, 0.255, 0.221, 0.341, 0.176]
])
# A41--A42
A41_A42 = np.array([
    [1, 1 / 2],
    [2, 1]
])
# A4的评价矩阵
A4_Emat = np.array([
    [0.124, 0.211, 0.235, 0.248, 0.182],
    [0.098, 0.182, 0.203, 0.302, 0.214]
])
# B11--B13
B11_B13 = np.array([
    [1, 1 / 2, 1 / 3],
    [2, 1, 1 / 2],
    [3, 2, 1]
])
# B1的评价矩阵
B1_Emat = np.array([
    [0.067, 0.194, 0.195, 0.193, 0.351],
    [0.06, 0.161, 0.191, 0.206, 0.382],
    [0.097, 0.134, 0.233, 0.353, 0.284]
])
# B21--B23
B21_B23 = np.array([
    [1, 1 / 2, 1 / 3],
    [2, 1, 1 / 2],
    [3, 2, 1]
])
# B2的评价矩阵
B2_Emat = np.array([
    [0.098, 0.182, 0.303, 0.302, 0.114],
    [0.074, 0.163, 0.221, 0.312, 0.231],
    [0.082, 0.198, 0.145, 0.365, 0.21]
])
# B31--B33
B31_B33 = np.array([
    [1, 1 / 4, 1 / 3],
    [4, 1, 2],
    [3, 1 / 2, 1]
])
# B3的评价矩阵
B3_Emat = np.array([
    [0.06, 0.157, 0.335, 0.312, 0.136],
    [0.007, 0.199, 0.223, 0.355, 0.216],
    [0.065, 0.054, 0.186, 0.391, 0.304]
])

# C11--C12
C11_C12 = np.array([
    [1, 3 / 2],
    [2 / 3, 1]
])
# C1的评价矩阵
C1_Emat = np.array([
    [0.093, 0.225, 0.331, 0.249, 0.101],
    [0.093, 0.213, 0.335, 0.265, 0.095]
])
# C21--C23
C21_C23 = np.array([
    [1, 3, 1 / 3],
    [1 / 3, 1, 1 / 5],
    [3, 5, 1]
])
# C2的评价矩阵
C2_Emat = np.array([
    [0.06, 0.161, 0.291, 0.306, 0.182],
    [0.097, 0.234, 0.333, 0.253, 0.084],
    [0.067, 0.194, 0.295, 0.293, 0.151]
])
# D11--D12
D11_D12 = np.array([
    [1, 4 / 3],
    [3 / 4, 1]
])
# D1的评价矩阵
D1_Emat = np.array([
    [0.074, 0.163, 0.221, 0.312, 0.231],
    [0.097, 0.234, 0.233, 0.253, 0.184]
])
# D21--D23
D21_D23 = np.array([
    [1, 2, 2],
    [1 / 2, 1, 1 / 2],
    [1 / 2, 2, 1]
])
# D2的评价矩阵
D2_Emat = np.array([
    [0.079, 0.198, 0.321, 0.29, 0.112],
    [0.093, 0.199, 0.35, 0.278, 0.08],
    [0.097, 0.234, 0.333, 0.253, 0.084]
])


def Eigenvalues_Feature_vector(phalanx):
    # 计算判断矩阵的特征值和特征向量
    a, b = np.linalg.eig(phalanx)
    # print("特征值是\n", a)
    print("特征值实部：", a.real)  # 显示特征值实部
    max_eigenvalue = max(a.real)
    print("最大特征值：", max_eigenvalue)
    num_shape = phalanx.shape
    CI = (max_eigenvalue - num_shape[0]) / (num_shape[0] - 1)
    print("---->> CI=", CI)
    if num_shape[0] == 2:
        RI = 0
    elif num_shape[0] == 3:
        RI = 0.52
    else:
        RI = 0.89

    if RI == 0 and CI == 0:
        CR = 0
        print("---->> CR=", CR)
    else:
        CR = CI / RI
        print("---->> CR=", CR)
    if CR < 0.1:
        print("---->> 一致性比例可接受！")
    else:
        print("---->> 一致性检验不通过！")
    print("\n")
    # print("特征向量是\n", b)  # numpy的特征向量是竖方向的，numpy输出的特征向量是单位化后的向量
    print("特征向量实部：", b.real)
    return b


def Weight_vector(phalanx):
    # 计算判断矩阵的权向量
    num = 0
    b = Eigenvalues_Feature_vector(phalanx)
    for i in range(len(b.real)):
        num += b.real[i][0]
    print("\n")
    print("指标权重是：")
    weight_list = []
    for j in range(len(b.real)):
        weight_num = b.real[j][0] / num
        weight_list.append(weight_num)
    print(weight_list)
    print("\n")
    return np.array([weight_list])


def get_point(phalanx, Emat):
    # 计算得分
    vec = Weight_vector(phalanx)
    Eva = np.dot(vec, Emat)
    print(Eva)
    grade = np.array([[20, 40, 60, 80, 100]])
    Eva_point = np.dot(Eva, grade.T)
    print("评价得分：----------->>", Eva_point[0][0])
    print("*" * 80)
    return Eva_point[0][0]


A_D_weightmat = Weight_vector(A_D)
A1_A4_weightmat = Weight_vector(A1_A4)
B1_B3_weightmat = Weight_vector(B1_B3)
C1_C2_weightmat = Weight_vector(C1_C2)
D1_D2_weightmat = Weight_vector(D1_D2)
point_A1 = get_point(A11_A14, A1_Emat)
point_A2 = get_point(A21_A22, A2_Emat)
point_A3 = get_point(A31_A33, A3_Emat)
point_A4 = get_point(A41_A42, A4_Emat)
point_B1 = get_point(B11_B13, B1_Emat)
point_B2 = get_point(B21_B23, B2_Emat)
point_B3 = get_point(B31_B33, B3_Emat)
point_C1 = get_point(C11_C12, C1_Emat)
point_C2 = get_point(C21_C23, C2_Emat)
point_D1 = get_point(D11_D12, D1_Emat)
point_D2 = get_point(D21_D23, D2_Emat)


def standard_layer_score(weightmat, point1, point2, point3=0, point4=0):
    # 标准层的得分
    pointlist = []
    for i in [point1, point2, point3, point4]:
        if i > 0:
            pointlist.append(i)
    pointmat = np.array(pointlist)
    print(pointlist)
    standard_point = np.dot(weightmat, pointmat.T)
    print("------>>>标准层得分", standard_point)
    return standard_point[0]


point_A = standard_layer_score(A1_A4_weightmat, point_A1, point_A2, point_A3, point_A4)
point_B = standard_layer_score(B1_B3_weightmat, point_B1, point_B2, point_B3)
point_C = standard_layer_score(C1_C2_weightmat, point_C1, point_C2)
point_D = standard_layer_score(D1_D2_weightmat, point_D1, point_D2)


def total_Score(weightmat, point1, point2, point3, point4):
    # 计算总得分
    pointlist = []
    for i in [point1, point2, point3, point4]:
        if i > 0:
            pointlist.append(i)
    pointmat = np.array(pointlist)
    print(pointlist)
    total_Score = np.dot(weightmat, pointmat.T)
    print("------>>>总得分", total_Score[0])


total_Score(A_D_weightmat, point_A, point_B, point_C, point_D)


#如果要用层次分析法问卷调查的数据，用一下程序进行归一化
a1=np.array([0.109,0.176,0.142,0.302,0.270])#评价矩阵分隔开的向量
A3_Emat = np.array([
    [0.088, 0.206, 0.234, 0.265, 0.207],
    [0.093, 0.129, 0.25, 0.34, 0.188],
    [0.007, 0.255, 0.221, 0.341, 0.176]
])
a2=np.array([20,40,60,80,100])
points=np.dot(A3_Emat,a2.T)
print(points)
#归一化处理，归到1-5之内
for point in points:
    point_num=point/100
    print("%.3f"%float(point_num))

运行结果截图