1 什么是因素分析法？ 
2 因素分析法的方法 
3 运用因素分析法的一般程序 
4 采用因素分析法时注意的问题 
 

什么是因素分析法？ 
　　因素分析法是依据分析指标与其影响因素的关系，从数量上确定各因素对分析指标影响方向和影响程度的一种方法。因素分析法既可以全面分析各因素对某一经济指标的影响，又可以单独分析某个因素对经济指标的影响，在财务分析中应用颇为广泛。 
因素分析法的方法 
 

　　连环替代法 
 

　　它是将分析指标分解为各个可以计量的因素，并根据各个因素之间的依存关系，顺次用各因素的比较值（通常即实际值）替代基准值（通常为标准值或计划值），据以测定各因素对分析指标的影响。 
　　例如，某一个财务指标及有关因素的关系由如下式子构成：实际指标：Po=×Bo×Co;标准指标：Ps=As×Bs×Cs；实际与标准的总差异为Po-Ps,P G 这一总差异同时受到A、B、C三个因素的影响，它们各自的影响程度可分别由以下式子计算求得： 
　　A因素变动的影响：（Ao-As）×Bs×Cs； 
　　B因素变动的影响；Ao×（Bo-Bs）×Cs； 
　　C因素变动的影响：Ao×Bo×（Co-Cs）。 
　　最后，可以将以上三大因素各自的影响数相加就应该等于总差异Po-Ps。
 
　　差额分析法 
 

　　它是连环替代法的一种简化形式，是利用各个因素的比较值与基准值之间的差额，来计算各因素对分析指标的影响。 
　　例如，企业利润总额是由三个因素影响的，其表达式为：利润总额=营业利润+投资损益±营业外收支净额，在分析去年和今年的利润变化时可以分别算出今年利润总额的变化，以及三个影响因素与去年比较时不同的变化，这样就可以了解今年利润增加或减少是主要由三个因素中的哪个因素引起的。 
 

　　指标分解法 
 

　　例如资产利润率，可分解为资产周转率和销售利润率的乘积。 
 

　　定基替代法 
 

　　分别用分析值替代标准值，测定各因素对财务指标的影响，例如标准成本的差异分析。
 
 
运用因素分析法的一般程序 
　　1、确定需要分析的指标； 
　　2、确定影响该指标的各因素及与该指标的关系； 
　　3、计算确定各个因素影响的程度数额。
 
采用因素分析法时注意的问题 
　　1、注意因素分解的关联性； 
　　2、因素替代的顺序性； 
　　3、顺序替代的连环性，即计算每一个因素变动时，都是在前一次计算的基础上进行，并采用连环比较的方法确定因素变化影响结果； 
　　4、计算结果的假定性，连环替代法计算的各因素变动的影响数，会因替代计算的顺序不同而有差别，即其计算结果只是在某种假定前提下的结果，为此，财务分析人员在具体运用此方法时，应注意力求使这种假定是合乎逻辑的假定，是具有实际经济意义的假定，这样，计算结果的假定性，就不会妨碍分析的有效性。 

1. 算法简介
 
层次分析法（AHP）是美国运筹学家萨蒂于上世纪70年代初，为美国国防部研究“根据各个工业部门对国家福利的贡献大小而进行电力分配”课题时，应用网络系统理论和多目标综合评价方法，提出的一种层次权重决策分析方法。
 层次分析法是一种解决多目标的复杂问题的定性与定量相结合的决策分析方法。该方法将定量分析与定性分析结合起来，用决策者的经验判断各衡量目标之间能否实现的标准之间的相对重要程度，并合理地给出每个决策方案的每个标准的权数，利用权数求出各方案的优劣次序，比较有效地应用于那些难以用定量方法解决的课题。
 
2. 算法基本原理
 
例子：
 
 
2.1. 解决问题的思路
 
层次分析法的基本思路是将所要分析的问题层次化；根据问题的性质和所要达成的总目标，将问题分解为不同的组成因素，并按照这些因素的关联影响及其隶属关系，将因素按不同层次凝聚组合，形成一个多层次分析结构模型；最后，对问题进行优劣比较并排列。
 
2.2. 层次分析法的步骤
 
1.建立层次结构模型
 
将决策的目标、考虑的因素（决策准则）和决策对象按照他们之间的相互关系分为最高层、中间层和最低层，绘出层次结构图。
最高层： 决策的目的、要解决的问题。
 最低层： 决策时的备选方案。
 中间层： 考虑的因素、决策的准则。
对相邻的两层，称高层为目标层，低层为因素层。
 
 
 
层次分析法所要解决的问题是关于最低层对最高层的相对权重的问题，按此相对权重可以对最低层中的各种方案、措施进行排序，从而在不同的方案中做出选择或形成选择方案的原则。
 
 
2.构造判断矩阵
 层次分析法中构造判断矩阵的方法是一致矩阵法，即：不把所有因素放在一起比较，而是两两相互比较；对此时采用相对尺度，以尽可能减少性质不同因素相互比较的困难，以提高准确度。
 
 
 
判断矩阵$a_{ij}$的标度方法
 
 
标度
含义
1
表示两个因素相比，具有同样重要性
3
表示两个因素相比，一个因素比另一个因素稍微重要
5
表示两个因素相比，一个因素比另一个因素明显重要
7
表示两个因素相比，一个因素比另一个因素强烈重要
9
表示两个因素相比，一个因素比另一个因素极端重要
2,4,6,8
上述两相邻判断的中值
倒数
因素$i$于$j$比较的判断$a_{ij}$，则因素$j$与$i$比较的判断$a_{ji}=1/a_{ij}$
 
3.层次单排序及其一致性检验
 对应于判断矩阵最大特征根$\lambda max$的特征向量，经归一化（使向量中各元素之和为1）后记为$W$。$W$的元素为同一层次元素对于上一层因素某因素相对重要性的排序权值，这一过程称为层次单排序。
 
 
 
定义一致性指标$CI=\frac{\lambda -n}{n-1}$：
 $CI=0$,有完全的一致性；
 $CI$接近于0，有满意的一致性；
 $CI$越大，不一致越严重。
 
 
为了衡量$CI$的大小，引入随机一致性指标$RI$
 
 
 
  随机一致性指标
  RI
   
   
n
1
2
3
4
5
6
7
8
9
10
11
RI
0
0
0.58
0.90
1.12
1.24
1.32
1.41
1.45
1.49
1.51
  
 
 
定义一致性比率：$CR=\frac{CI}{RI}$，一般认为一致性比率$CR<0.1$时，认为A的不一致程度在容许范围之内，有满意的一致性，通过一致性检验。可用其归一化特征向量作为权向量，否则要重新构造成对比较矩阵A，对$a_{ij}$加以调整。
 
示例：
 
 
4.层次总排序及其一致性检验
 
计算某一层次所有因素对于最高层（总目标）相对重要性的权值，称为层次总排序。
这一过程是从最高层次到最低层次依次进行的。
 
 A层$m$个因素$A_1,A_2,\cdot \cdot \cdot ,A_m,$对总目标Z的排序为$a_1,a_2,\cdot \cdot \cdot ,a_m$。
 B层$n$个因素对上层A中因素为$A_j$的层次单排序为$b_{1j},b_{2j},\cdot \cdot \cdot ,b_{nj}(j=1,2,3,\cdot \cdot \cdot ,m)$。
 
 
 
B层的层次总排序(即B层第$i$个因素对总目标的权值为：${\sum }_{j=1}^m{a}_j{b}_{ij}$)为：
 $B_1:a_1{b}_{11}+a_2{b}_{12}+\cdot \cdot \cdot +a_m{b}_{1m},$
 $B_2:a_1{b}_{21}+a_2{b}_{22}+\cdot \cdot \cdot +a_m{b}_{2m},$
 $\cdot \cdot \cdot$
 $B_n:a_1{b}_{n1}+a_2{b}_{n2}+\cdot \cdot \cdot +a_m{b}_{nm},$
 
 
层次总排序的一致性比率为:$CR=\frac{a_{1}C{I}_1+a_{2}C{I}_2+\cdot \cdot \cdot +a_{m}C{I}_m}{a_{1}R{I}_1+a_{2}R{I}_2+\cdot \cdot \cdot +a_{m}R{I}_m}$,当$CR<0.1$时，认为层次总排序通过一致性检验。
 例子：
 
 
3.算法总结
 
应用领域：经济计划个管理，能源政策和分配，人才选拔和评价，生产决策，交通运输，科研选题，产业结构，教育，医疗，环境，军事等。
处理问题类型：决策、评价、分析、预测等。
建立层次分析结构模型是关键一步，要有主要决策层参与。
构造成对比较矩阵是数量依据，应由经验丰富、判断力强的专家给出。
 
4.参考
 
层次分析法建模——《百度文库》

 
目录
 
层次分析法概述
定义
步骤归纳
例子
应用实例
  
Python实现
程序如下：
运行结果截图
 

 
层次分析法概述
 
定义
 
本文所有图片均来自本人的OneNote笔记
 
 
 
步骤归纳
 

 
 
 
例子
 
 
建立层次结构模型
 
 
 
构造判断(成对比较)矩阵
 
 
 第二层A的各个因素对目标层Z的成对比较矩阵（专家打分法）
 
 说明C2的重要性是C1的两倍
 第三层B的各个因素A1，A2……A5的成对比较矩阵分别如下：
 
 
 
层次单排序及其一致性检验
 
 
 
 
 
 
 
 
 
 
 
 0.6=1/（1+1/2+1/6） 矩阵中其他数值同理
 0.587=1/3（0.6+0.615+0.545）
 
 
层次单排序及其一致性检验
 
 
 
 
 
 
 
 
应用实例
 

 
 
 
 
 
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))

 
运行结果截图
 

2014年参加数学建模美赛， 其中一道题是选出5大优秀教练，数据来源要求自行寻找。 在比赛中，我们运用了层次分析法（AHPAnalytic Hierarchy Process）进行建模，好不容易理解了这一方法的思想，在自己的博客里记录一下，希望可以帮助初次接触层次分析法的人，更快地理解这一的整体思想，也利于进一步针对细节进行学习。文章内容主要参阅 《matlab数学建模算法实例与分析》，部分图片来源于WIKI

  
 
 
 
文章分为2部分：
 
1第一部分以通俗的方式简述一下层次分析法的基本步骤和思想
 
2第二部分介绍一下我们队伍数学建模过程中，对层次分析法的应用，中间有些地方做了不严谨的推理，例如关于一致性的检验，如有人发现不正确，希望可以指正
 
 
 
第一部分：
 
 
 
层次分析法（Analytic Hierarchy Process ，简称 AHP ）是对一些较为复杂、较为模糊的问题作出决策的简易方法，它特别适用于那些难于完全定量分析的问题。它是美国运筹学家T. L. Saaty 教授于上世纪 70 年代初期提出的一种简便、灵活而又实用的多准则决策方法。
 
人们在进行社会的、经济的以及科学管理领域问题的系统分析中，面临的常常是一个由相互关联、相互制约的众多因素构成的复杂而往往缺少定量数据的系统。层次分析法为这类问题的决策和排序提供了一种新的、简洁而实用的建模方法。 
 

运用层次分析法建模，大体上可按下面四个步骤进行： 
 （i ）建立递阶层次结构模型； 
 （ii ）构造出各层次中的所有判断矩阵； 
 （iii ）层次单排序及一致性检验； 
 （iv ）层次总排序及一致性检验。 
 
 
 
这四个步骤中，前两个步骤最容易理解，后两个步骤需要一点时间理解
 
 
 
首先从层次结构模型说起
 
层次分析法是用来根据多种准则，或是说因素从候选方案中选出最优的一种数学方法
 
 
最顶层是我们的目标，比如说选leader，选工作，选旅游目的地
 
中间层是判断候选方物或人优劣的因素或标准
 
选工作时有：发展前途  ，待遇 ，工作环境等
 
选leader时有：年龄，经验，教育背景，魅力
 
 
 
在分层以后，为了选出最优候选
 
给目标层分配值1.000
 
然后将这一值作为权重，分配给不同因素，对应因素的权重大小代表该因素在整个选择过程中的重要性程度
 
然后对于候选方案，每一个标准再将其权重值分配给所有的候选方案，每一方案获得权重值，来源于不同因素分得的权重值的和
 
 
 
如下图：
 
            目标层分配值为1， 然后我们给了4个候选方案评估标准 criterion 1 、 criterion 2、criterion 3、criterion 4
 
            假设我们认为这四个标准同等重要， 于是目标层的值1 就被均分到 4个准则上， 每个准则获得的值为 0.25
 
            然后我们从评估标准 criterion 1 出发， 考虑在该评估标准下， 3 个候选方案的优劣比如何。 假如我们认为在标准1 的衡量下，   3 个方案完全平等， 方案1 在该标准下的得分就应该是： 0.25 * (1/3) 
 
           同理， 如果我们假设剩下的 3 个标准下， 3个候选方案都是平分秋色， 那么方案 1 的最终得分就应该是
 
           0.33 =  0.25 * (1/3)   +   0.25 * (1/3)   +  0.25 * (1/3)  +  0.25 * (1/3) 
 
           最终获得的各个方案的的权重值的和依然为1
 
 
 
 
这不就是一个简单的权重打分的过程吗？为什么还要层次分析呢。这里就有两个关键问题：
 
1每个准则（因素）权重具体应该分配多少
 
2每一个候选方案在每一个因素下又应该获得多少权重
 
 
 
这里便进入层次分析法的第二个步骤，也是层次分析法的一个精华（构造比较矩阵（判断矩阵）comparison matrix）：
 
 
 
首先解决第一个问题：每个准则（因素）权重具体应该分配多少？
 
如果直接要给各个因素分配权重比较困难，在不同因素之间两两比较其重要程度是相对容易的
 
 
 
 
现在将不同因素两两作比获得的值aij  填入到矩阵的 i 行 j 列的位置，则构造了所谓的比较矩阵，对角线上都是1， 因为是自己和自己比
 
这个矩阵容易获得，我们如何从这一矩阵获得对应的权重分配呢
 
这里便出现了一个比较高级的概念，正互反矩阵和一致性矩阵
 
首先正互反矩阵的定义是：
 
 
 
 
我们目前构造出的矩阵很明显就是正互反矩阵
 
 
 
而一致性矩阵的定义是：
 

 
这里我们构造出的矩阵就不一定满足一致性，比如我们做因素1：因素2= 4：1  因素2：因素3=2:1    因素1：因素3=6:1（如果满足一致性就应该是8:1），我们就是因为难以确定各因素比例分配才做两两比较的，如果认为判断中就能保证一致性，就直接给出权重分配了
 
 
 
到了关键部分，一致性矩阵有一个性质可以算出不同因素的比例
 
 
 
 
这里的w就是我们想要知道的权重，所以通过 求比较矩阵的最大特征值所对应的特征向量，就可以获得不同因素的权重，归一化一下（每个权重除以权重和作为自己的值，最终总和为1）就更便于使用了。（实际上写这篇博客就是因为，重新翻了线代的书才好不容易理解这里的，就想记录下来）
 
 
 
这里补充一点线性代数的知识：
 
    n阶矩阵有n个特征值，每个特征值对应一个n维特征列向量，特征值和特征向量的计算方法这里就省略了，反正书中的程序是直接用matlab 的eig函数求的
 
 
 
这里不能忘了，我们给出的比较矩阵一般是不满足一致性的，但是我们还是把它当做一致矩阵来处理，也可以获得一组权重，但是这组权重能不能被接受，需要进一步考量
 
例如在判断因素1,2,3重要性时，可以存在一些差异，但是不能太大，1比2重要，2比3 重要，1和3比时却成了3比1重要，这显然不能被接受
 
 
 
于是引入了一致性检验：
 
          一致性的检验是通过计算一致性比例CR 来进行的
 
          
 
          当 10 . 0 < CR 时，认为判断矩阵的一致性是可以接受的，否则应对判断矩阵作适当修正。 
 
 
 
CI的值由判断矩阵计算获得，RI的值查表获得，具体的计算公式这里就略去，重点是理解为什么要做一致性检验
 
 
 
 
 
接下来解决第二个问题：每一个候选方案在每一个因素下又应该获得多少权重
 
 
 
这里则需要将不同候选方案，在不同因素下分别比较，具体的比较方法，还是使用比较矩阵，只不过之前准则层的比较矩阵比较的对象是因素，这里比较的是某一因素下，候选方案的优劣， n个因素则需构造出来n个比较矩阵
 
例如在工作环境的因素下，工作1与工作2相比为 ：4:2，工作2与工作3=2:1  工作1：工作3=6：1.，这样构造一个矩阵，再用之前的一致性矩阵的方法就可以求出一个权重，然后相对应因素（这里是工作环境）所拥有的权值就可以按这个权重比例分配给不同候选物或人。
 
 
 
其他因素同理
 
 
 
 
 
至此两个问题就都得到了解决
 
最终将每个候选物、人从不同因素获得的权值求和，就可以得到不同候选对于目标层的权值大小，继而可以根据值的大小，来选出优劣
 
 
 
对于第一部分的总结：
 
 
 
通过对层次分析法的基本了解，不难发现层次分析法对人们的思维过程进行了加工整理，提出了一套系统分析问题的方法，为科学管理和决策提供了较有说服力的依据。 
 
 
但很明显的缺点是，整个分析过程似乎都是依赖于人的主观判断思维，一来不够客观，二来两两比较全部人为完成，还是非常耗费精力的，尤其是当候选方案比较多的时候。
 
 
 
 
 
 
文章的第二部分：
 

 层次分析法的变形应用（也可能本来就是这样用的，只不过参考书上没这样说，外语
 论文没细看）解决最优教练选择问题
 
 
 
目标：选最优教练
 
 
 
准则：  
 
 
 
 
 
职业生涯所带队伍的胜率      
职业生涯所带队伍的胜场            
从教时长（年）          
职业生涯所带队伍获奖状况（化成分数）
 
 
  
 
候选：  众多教练
 
 
 
准则层比较矩阵获得
 
 
 
 
 
准则层的比较矩阵好构造 ，作6次两两比较，就可以获得4*4的比较矩阵
 
 
 
 
候选层比较矩阵
 
 
 
每一个准则对应下来的 候选层 已经有定量的数据了。 这里其实就不再需要候选层比较矩阵了， 因为有4000个教练的话， 得比4000*3999次，可以直接利用定量的数据计算权重。
 
例如“职业生涯所带队伍的胜场” 这一准则对应到每个教练都有直接相应数据的，例如教练 A, B, C 职业生涯所带队伍胜场数为 100,150, 90. 此时该准则下得到的分数， 就应当按照 10:5:9 的比例来进一步划分。 
 
 
类似的，胜率准则 下就根据  “胜率”   计算权重分配比例。 从教时长准则下就根据 “从教时间的年数” 计算权重分配比例
 
 
 
这里又有两点可以注意：
 
 
 
1.不同因素下数据的量纲和性质不一样，直接用数据作比来分配，不一定合适，比如胜率越要接近1越难，0.7比胜率0.5  和胜率0.9比0.7  ，后者比值比前者小，这显然不合适。这里可以利用指数函数和对数函数对数据先做一次处理， 再作为权重分配的依据。
 
 
 
2.这里的用定量数据作比获得的矩阵显然满足一致性要求，不需要做一致性检验。以职业生涯所带队伍的胜场数为例，如果教练 A, B, C 职业生涯所带队伍胜场数为 100,150, 90。 那么 A：B :C 无论怎么作比， 都不会违反 10:15:9 的一致性。 
 
 
 
综上就对层次分析法完成了定性定量结合的应用，以及对多个候选方案的比较（其实只是就是用程序控制数据作比，我们水平有限，能成功应用该方法已经不容易了）
 
 
 
很遗憾的是比赛时编写的代码存放的优盘不慎丢失， 没有办法把代码共享出来， 这里只能将书中的代码贴出。比赛建模时， 就是在这个代码基础上进行修改实现。 只要理解了下列代码，编写符合自己需求的程序， 应当是水到渠成的事。
 
 
 
 
 
 
 
 matlab 代码（对应于文章第一部分选 Leader 的内容）:
 
 
 
 
 
clc,clear
fid=fopen('txt3.txt','r');
n1=6;n2=3;
a=[];
for i=1:n1
	tmp=str2num(fgetl(fid));
	a=[a;tmp]; %读准则层判断矩阵
end
for i=1:n1
	str1=char(['b',int2str(i),'=[];']);
	str2=char(['b',int2str(i),'=[b',int2str(i),';tmp];']);
	eval(str1);
	for j=1:n2
		tmp=str2num(fgetl(fid));
		eval(str2); %读方案层的判断矩阵
	end
end
ri=[0,0,0.58,0.90,1.12,1.24,1.32,1.41,1.45]; %一致性指标
[x,y]=eig(a);  % matlab eig(a) 返回矩阵的特征值和特征向量， 这里的 x 为矩阵 a 的 n 个特征向量， y 为矩阵 a 的 n 个特征值
lamda=max(diag(y));  %  eig 函数返回的 y 是矩阵形式保存的， dig(y) 提取对角线上的n 个特征值到一个数组中， 求出最大特征值 lamda
num=find(diag(y)==lamda);  % 返回最大特征的索引
w0=x(:,num)/sum(x(:,num));  % x( :num) 为最大特征值所对应的那一列特征向量。 w0 中准则层计算出的 包含归一化后的n 个权重值
cr0=(lamda-n1)/(n1-1)/ri(n1)

for i=1:n1 % 循环 n 个维度， 针对每个维度， 都计算一次方案层的比较矩阵及其权重值
	[x,y]=eig(eval(char(['b',int2str(i)])));
	lamda=max(diag(y));
	num=find(diag(y)==lamda);
	w1(:,i)=x(:,num)/sum(x(:,num));
	cr1(i)=(lamda-n2)/(n2-1)/ri(n2);
end
cr1, ts=w1*w0, cr=cr1*w0
 
 
 
txt3.txt 中的内容， 前6行为准则层的 6 x 6 比较矩阵， 后 18 行则为 6 个准则下， 各自的 3 x 3 的比较矩阵。 
 
1 1 1 4 1 1/2
1 1 2 4 1 1/2
1 1/2 1 5 3 1/2
1/4 1/4 1/5 1 1/3 1/3
1 1 1/3 3 1 1
2 2 2 3 3 1
1 1/4 1/2
4 1 3
2 1/3 1
1 1/4 1/5
4 1 1/2
5 2 1
1 3 1/3
1/3 1 1/7
3 7 1
1 1/3 5
3 1 7
1/5 1/7 1
1 1 7
1 1 7
1/7 1/7 1
1 7 9
1/7 1 1
1/9 1 1
 
 
 
再上一段 JAVA 代码， 方便 JAVA 童鞋参考， 这部分仅仅展示了如何用JAVA 代码进行准则层比较矩阵计算 。 
 
 
 
import org.apache.commons.math3.linear.*;


public class MatrixTester {
    public static void main(String[] args) {

        // Create a real matrix with two rows and three columns, using a factory
        // method that selects the implementation class for us.
        double[][] matrixData = {   {1d,    1d,     1d,     4d,     1d,     1d/2d},
                                    {1d,    1d,     2d,     4d,     1d,     1d/2d},
                                    {1d,    1d/2d,  1d,     5d,     3d,     1d/2d },
                                    {1d/4d, 1d/4d,  1d/5d,  1d,     1d/3d,  1d/3d },
                                    {1d,   1d,     1d/3d,  3d,     1d,     1d },
                                    {2d,    2d,     2d,     3d,     3d,     1d },
                                };
        RealMatrix m = MatrixUtils.createRealMatrix(matrixData);



        // One more with three rows, two columns, this time instantiating the
        // RealMatrix implementation class directly.
        double[][] matrixData2 = {{1d, 2d}, {2d, 5d}, {1d, 7d}};
        RealMatrix n = new Array2DRowRealMatrix(matrixData2);

        // Note: The constructor copies  the input double[][] array in both cases.
        // Now multiply m by n
//        RealMatrix p = m.multiply(n);
//        System.out.println(p.getRowDimension());    // 2
//        System.out.println(p.getColumnDimension()); // 2
//
//        // Invert p, using LU decomposition
//        RealMatrix pInverse = new LUDecomposition(p).getSolver().getInverse();


        RealMatrix D = new EigenDecomposition(m).getD();
        RealMatrix V = new EigenDecomposition(m).getV();

        for(int i=0; i<D.getRowDimension();i++)
        {
            System.out.println(D.getRowMatrix(i));
        }

        for(int i=0; i<V.getRowDimension();i++)
        {
            System.out.println(V.getRowMatrix(i));
        }

        // 特征值
        double maxLamda;
        int columIndexForMaxLamda=0;
        maxLamda=D.getEntry(0,0);

        for(int i =0, j=0; i<D.getRowDimension()&&j<D.getColumnDimension();i++,j=i)
        {
            double lamda = D.getEntry(i,j);
            if(maxLamda<lamda)
            {
                maxLamda=lamda;
                columIndexForMaxLamda = j;
            }
            System.out.println(lamda);
        }

        // 输出尚未做归一化 w1, w2, w3, w4, w5, w6 ， 
        System.out.println(V.getColumnMatrix(columIndexForMaxLamda));

    }
}