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

    }
}
 
 
 
 

 
聊聊AHP层次分析法
 
1 什么是AHP层次分析法？
2 这个方法是干吗呢？在什么场景使用？
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表格读入并进行一致性检验以及权重的计算
   
3.4 Excel实现
3.5 如何得到总权重
  
4 参考
5 附录：AHP层次分析法的Excel版本实现

 
1 什么是AHP层次分析法？
 
大家直接Google层次分析法，会发现一条令人哭笑不得，十分尴尬的结果：
 
 想到自己原来参加数学建模竞赛的时候也是经常用AHP层次分析法。。。真的low吗？（笑哭）
 
那究竟什么是貌似很low的层次分析法呢？
 
层次分析法：AHP（The analytic hierarchy process），从英文名可以看出来这个方式是一个分析层级的过程，啥叫层级？这么拗口？别急，下面详细解释一波！
提出者：在20世纪70年代中期由美国运筹学家托马斯·塞蒂（T.L.saaty）正式提出
层次分析法是将决策问题按总目标、各层子目标、评价准则直至具体的备投方案的顺序分解为不同的层次结构，然后用求解判断矩阵特征向量的办法，求得每一层次的各元素对上一层次某元素的优先权重，最后再加权和的方法递阶归并各备择方案对总目标的最终权重，此最终权重最大者即为最优方案。
 
2 这个方法是干吗呢？在什么场景使用？
 
确定指标权重
确定最优方案（本质也是确定各个方案的权重，一般选取权重最大的为最优方案）
 
3 AHP层次分析法的实现
 
3.1 步骤
 
建立层次结构模型
 
对决策对象调查研究，将目标体系所包含的因素划分为不同的层次。一般有三层：最高层（总目标），中间层（目标层），最低层（方案层）。【说人话：就是构建一个指标体系，分一二三级指标！】
 
构造成对比较矩阵
 
按照层次结构模型，从上到下逐层构造判断矩阵。每一层元素都以相邻上一层次各元素为准则，按1-9标度方法两两比较构造判断矩阵。【说人话：构建一个矩阵，里面的数值是业务人员对两两指标的评分！】
 
一致性检验
 
【下面单独解析】
 【说人话：就是上面第二步构建的矩阵如果不符合要求，就要重打！检验的过程就是一致性检验！如何检验？见下面单独解析】
 
确定权重和最优方案
 
一旦上面一致性检验通过之后，就可以根据矩阵特征向量来确定二级指标和三级指标的权重！
 
3.2 实际的例子
 
下面以具体的例子来实现上述的步骤
 
3.2.1 背景
 
问题背景：
 
我们现在需要给商户进行评分，作为筛选白名单的依据。
商户的评分维度现在假设有6个，记为[企业B1 交易B2 活跃B3 经营B4 风险B5 成长B6]
现在假设已经算出了各个维度的评分，需要根据这6项得分算出商户的总得分，在计算的过程中，6个维度的指标权重就显得尤为重要了，是1/6吗？还是有不同的权重？如果不同的，如何得到呢？
基于这个问题的背景，AHP层次分析法就闪亮登场了！
 
3.2.2 Step1 构建层次结构模型
 
注：为了保护公司隐私，下述信息为真实项目案例脱敏之后的结果！
 
 同时每一个二级指标下面对应着有很多三级指标
 
 这样第一步层次结构模型就搭建完毕了！可以看到：
 
总目标：给商户进行评分
目标层：即评估商户的6个维度的指标
方案层：即商户每个二级指标下对应的三级指标！
 
3.2.3 Step2 构造成对比较矩阵
 
以商户评分-交易-C21~C27为例，专家打分结果见下表：
 
 这个表的含义是什么呢？怎么打出来的呢？
 
 
C22-C21为8 表示 指标C22 是 C21重要性的8倍。
 
 
判断矩阵（成对比较矩阵）构造采用Saaty引用的1-9标度方法，各级标度含义见下表：
 
 也就是说我们评判矩阵的重要性就按照1-9打分即可，如果变量A对B重要性是x，那么B对A就是1/x！
 
 
同时可以看到判断矩阵是有一些特殊的性质的，知道了下三角，上三角都是它的倒数，且对角线元素都是1
 
 
这样，我们分别对二级指标（B1~B6）以及对应的各三级指标进行评分，构建判断矩阵，本案例应构建的判断矩阵应该有1+6=7个，但企业仅一个维度无需判别，所以应该是构造6个判断矩阵。
 
3.2.4 Step3 一致性检验
 
问题：什么叫一致性检验呢？为什么要进行一致性检验呢？
 
首先给出判断矩阵一致性的定义：
 
 可以看出：
 
判断矩阵都是互反矩阵
但是互反矩阵不一定都是一致性矩阵，需要再多一个条件，也就是条件（3）：
 
 这个条件的含义是什么呢？当时刚看的时候小编也一脸懵逼，但仔细想想，从现实的含义出发理解也就不难了。下面小编就尝试用通俗的语言解释一下：
 
① 如果k=j，则条件（3）肯定成立，分母为1
 
② 如果k=i，则条件（3）也成立，即和条件（2）重合了
 
③ 如果 k≠i 且 k≠j 这时候表示什么意思呢？举两个例子就很清楚了！
 
 通过上面两个矩阵的对比，可以得出条件（3）的含义就是：
 
如果变量2对1的重要性是4，变量3对1的重要性是8，那么变量3对2的重要性应该就是8/4=2 这是符合我们常理的，如果结果不为2，那么就不是一致性矩阵了。
 
既然知道了矩阵一致性的含义，那么如何去检验和判断呢？是不是都得这么一个一个去算？3×3矩阵还是ok的 但维度提升后，一个一个手算就会很耗时了。那有没有其余的方法呢？答案是有的：
 
 对了，这里有两个重要的线代结论：
 
矩阵对角线元素之和为特征值之和。
矩阵特征值的乘积等于矩阵行列式结果。
 
但是就像人无完人一样，判断矩阵完全符合一致性的可能性也比较小，所以能否尝试放松条件？答案那必须阔以哈！
 思路如下：
 
如果判断矩阵为一致性矩阵，那么1个特征值就为矩阵的维数，其余特征值均为0。
但是现在上述情况不成立，可我们还是希望1个特征值尽可能接近矩阵的维数，其余接近0，如何衡量呢？我们的做法是将（最大特征值）- 特征值之和（矩阵维数）再除以（矩阵维数-1），记为C.I 作为检验判断矩阵一致性的指标。
可以看出C.I应该是越小越好。即分子越接近于0
 
根据上面的分析，我们知道，计算出这个矩阵的 C.I 然后再判断一致性即可！但又遇到了一个问题：就是C.I的计算结果和矩阵的维数是有关系的。
 
判断矩阵的阶数m越大，判断的主观因素造成的偏差越大，偏离一致性也就越大，反之，偏离一致性越小。
阶数m≤2时，C.I=0
基于上述两点原因，引入平均随机一致性指标R.I，随判断矩阵的阶数而变化。
 
故我们的一致性判别指标变成了：一致性指标C.I除以同阶随机一致性指标R.I的比值，称为一致性比率。
 C.R = C.I / R.I
 
随机一致性指标R.I的取值见下方：
 
 注：不同的地方对于这个R.I的取值稍有不同，不过影响不大！
 
具体到本案例，对于上面的判断矩阵，是否通过一致性的检验呢？检验的方法有两种：一种是Excel来判断，一种是Python来判断。
 
Python判断的思路：
 
首先求解判断矩阵的特征值
计算C.I 将 (最大特征值-维数) /（维数-1）
查表得R.I
计算C.R ，如果小于0.1，可视为通过一致性检验！否则不通过，继续调整判断矩阵。
 
import numpy as np
x = np.array([[1, 1/8, 1/5, 1/2, 1/8, 1/5, 1/2],
            [8,1,1/2,1,1/2,1/2,1],
            [5,2,1,1,1/2,1,1],
            [2,1,1,1,1/4,1/2,1],
            [8,2,2,4,1,0.5,1],
            [5,2,1,2,2,1,1/2],
            [2,1,1,1,1,2,1]])
x
 
array([[1.   , 0.125, 0.2  , 0.5  , 0.125, 0.2  , 0.5  ],
       [8.   , 1.   , 0.5  , 1.   , 0.5  , 0.5  , 1.   ],
       [5.   , 2.   , 1.   , 1.   , 0.5  , 1.   , 1.   ],
       [2.   , 1.   , 1.   , 1.   , 0.25 , 0.5  , 1.   ],
       [8.   , 2.   , 2.   , 4.   , 1.   , 0.5  , 1.   ],
       [5.   , 2.   , 1.   , 2.   , 2.   , 1.   , 0.5  ],
       [2.   , 1.   , 1.   , 1.   , 1.   , 2.   , 1.   ]])
 
a,b=np.linalg.eig(x) ##特征值赋值给a，对应特征向量赋值给b 
print(a)
print(b)
 
[ 7.66748795+0.j          0.03940202+1.87298751j  0.03940202-1.87298751j
  0.05735978+1.26682712j  0.05735978-1.26682712j -0.59654648+0.j
 -0.26446506+0.j        ]
[[ 8.98495759e-02+0.j         -1.18246709e-01-0.01263084j
  -1.18246709e-01+0.01263084j  3.98351769e-04+0.13474951j
   3.98351769e-04-0.13474951j -6.03676850e-02+0.j
   3.56785054e-02+0.j        ]
 [ 3.09527955e-01+0.j         -9.23924468e-02+0.3397639j
  -9.23924468e-02-0.3397639j   6.18132774e-01+0.j
   6.18132774e-01-0.j          1.47584293e-01+0.j
  -3.38554025e-01+0.j        ]
 [ 3.70552823e-01+0.j          1.21048811e-01+0.01895149j
   1.21048811e-01-0.01895149j  1.17043949e-01-0.54495727j
   1.17043949e-01+0.54495727j  4.62647077e-02+0.j
   6.66602397e-01+0.j        ]
 [ 2.45301866e-01+0.j         -9.37531583e-02-0.05462322j
  -9.37531583e-02+0.05462322j -2.36156222e-01-0.16043371j
  -2.36156222e-01+0.16043371j -2.55128037e-01+0.j
  -3.64760465e-01+0.j        ]
 [ 5.54526869e-01+0.j          1.25504484e-01+0.41339602j
   1.25504484e-01-0.41339602j -3.92432327e-01+0.04185286j
  -3.92432327e-01-0.04185286j  5.80407359e-01+0.j
   4.49197914e-01+0.j        ]
 [ 4.85303610e-01+0.j          5.72831146e-01+0.j
   5.72831146e-01-0.j         -2.76707723e-02+0.02135125j
  -2.76707723e-02-0.02135125j -5.82755720e-01+0.j
  -3.07080830e-01+0.j        ]
 [ 3.94483785e-01+0.j          8.24130634e-02-0.55993026j
   8.24130634e-02+0.55993026j -1.98177832e-01+0.10638157j
  -1.98177832e-01-0.10638157j  4.80486159e-01+0.j
   1.03062419e-01+0.j        ]]
 
CI = (max(a) - x.shape[0]) / (x.shape[0]-1)
RI = 1.36
CR = CI / RI
if CR < 0.1:
    print('判断矩阵x一致性检验通过, 值为 %.2f' % CR)
else:
    print('一致性检验未通过，继续调整判断矩阵')
 
判断矩阵x一致性检验通过, 值为 0.08


/Users/apple/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:5: ComplexWarning: Casting complex values to real discards the imaginary part
 
Excel判断的思路和上述Python类似，不过在Excel中进行求解判断的时候可以采用几种近似的方法进行处理，具体有根法，和法，幂法，具体可以参考：https://wenku.baidu.com/view/96cc92ac195f312b3069a54e.html
 
3.2.5 Step4 确定权重和最优方案
 
如何确定上述C21~C27 7个指标的权重呢？
 
根据递阶层次结构权重解析：将特征向量和特征值相乘，结果即为权重
 
import numpy as np
np.set_printoptions(suppress=True)
 
b
 
array([[ 0.08984958+0.j        , -0.11824671-0.01263084j,
        -0.11824671+0.01263084j,  0.00039835+0.13474951j,
         0.00039835-0.13474951j, -0.06036768+0.j        ,
         0.03567851+0.j        ],
       [ 0.30952795+0.j        , -0.09239245+0.3397639j ,
        -0.09239245-0.3397639j ,  0.61813277+0.j        ,
         0.61813277-0.j        ,  0.14758429+0.j        ,
        -0.33855403+0.j        ],
       [ 0.37055282+0.j        ,  0.12104881+0.01895149j,
         0.12104881-0.01895149j,  0.11704395-0.54495727j,
         0.11704395+0.54495727j,  0.04626471+0.j        ,
         0.6666024 +0.j        ],
       [ 0.24530187+0.j        , -0.09375316-0.05462322j,
        -0.09375316+0.05462322j, -0.23615622-0.16043371j,
        -0.23615622+0.16043371j, -0.25512804+0.j        ,
        -0.36476046+0.j        ],
       [ 0.55452687+0.j        ,  0.12550448+0.41339602j,
         0.12550448-0.41339602j, -0.39243233+0.04185286j,
        -0.39243233-0.04185286j,  0.58040736+0.j        ,
         0.44919791+0.j        ],
       [ 0.48530361+0.j        ,  0.57283115+0.j        ,
         0.57283115-0.j        , -0.02767077+0.02135125j,
        -0.02767077-0.02135125j, -0.58275572+0.j        ,
        -0.30708083+0.j        ],
       [ 0.39448379+0.j        ,  0.08241306-0.55993026j,
         0.08241306+0.55993026j, -0.19817783+0.10638157j,
        -0.19817783-0.10638157j,  0.48048616+0.j        ,
         0.10306242+0.j        ]])
 
w = np.dot(b,a)
print(w)
 
[0.41213046-0.j 1.16568062+0.j 3.97002508+0.j 2.70613214+0.j
 2.09704971+0.j 4.13778295+0.j 4.52252119+0.j]
 
所以C21~C27对应的权重见上方！
 
结果很奇怪，试验一下其余的矩阵
 
x2 = np.array([[1,1/4,1/8],
             [4,1,1/3],
             [8,3,1]])
x2
 
array([[1.        , 0.25      , 0.125     ],
       [4.        , 1.        , 0.33333333],
       [8.        , 3.        , 1.        ]])
 
a,b=np.linalg.eig(x2) ##特征值赋值给a，对应特征向量赋值给b 
print(a)
print(b)
 
[ 3.01829471+0.j         -0.00914735+0.23480874j -0.00914735-0.23480874j]
[[ 0.1014959 +0.j          0.05074795+0.08789803j  0.05074795-0.08789803j]
 [ 0.35465936+0.j          0.17732968-0.30714401j  0.17732968+0.30714401j]
 [ 0.92947045+0.j         -0.92947045+0.j         -0.92947045-0.j        ]]
 
w = np.dot(b,a)
(w/sum(w) )[0]
 
(0.0614556613808721+0j)
 
应该没啥问题。但不过Python结果还是有点奇怪，可以以下面这个Python版本为准！
 
3.3 Python实现
 
import numpy as np

#  建立平均随机一致性指标R.I
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}

def get_w(array):
    print('' * 50)
    print('*' * 50)
    print('我是炫酷的分割线')
    print('-' * 50)
    print('' * 50)
    # 1、计算出阶数 看这个数组是几维的 也就是后面对应字典查询！
    row = array.shape[0]  
    # 2、按列求和
    a_axis_0_sum = array.sum(axis=0) 
    # 3、得到新的矩阵b 就是把每一个数都除以列和 
    b = array / a_axis_0_sum  
    # 4、计算新矩阵b行和
    b_axis_1_sum = b.sum(axis=1)  
    # 5、将b_axis_1_sum每一个值除以总和
    W = b_axis_1_sum / sum(b_axis_1_sum)
    # 6、将原始矩阵乘以W
    a_W = np.dot(array, W)
    # 7、求解最大特征值 
    lambda_max = 0
    for i in range(len(a_W)):
        lambda_max += (a_W[i] / W[i])
    lambda_max = lambda_max / len(a_W)
    # 8、检验判断矩阵的一致性
    C_I = (lambda_max - row) / (row - 1)
    R_I = RI_dict[row] 
    C_R = C_I / R_I 
    if C_R < 0.1:
        print('矩阵 %s 一致性检验通过' % (array))
        print('判断矩阵对应的指标的权重为：%s' % W)
        print('判断矩阵对应的最大特征值为 %.2f' % lambda_max)
        print('大功告成！！！')
        return W
    else:
        print('矩阵 %s 一致性检验未通过，需要重新进行调整判断矩阵' % (array))
    
def main(array):
    if type(array) is np.ndarray:
        return get_w(array)
    else:
        print('请输入正确的numpy对象')


if __name__ == '__main__':
    # 由于地方问题，矩阵我就写成一行了
    # 检验以下判断矩阵的一致性并输出权重
    a = np.array([[1, 1 / 3, 1 / 8], [3, 1, 1 / 3], [8, 3, 1]])
    b = np.array([[1, 3, 6], [1 / 3, 1, 4], [1 / 5, 1 / 2, 1]])
    c = np.array([[1, 1, 3], [1, 1, 3], [1 / 3, 1 / 3, 1]])
    d = np.array([[1, 3, 4], [1 / 3, 1, 1], [1 / 4, 1, 1]])
    e = np.array([[1, 2, 7, 5, 5], [1 / 2, 1, 4, 3, 3], [1 / 7, 1 / 4, 1, 1 / 2, 1 / 3], [1 / 5, 1 / 3, 2, 1, 1], [1 / 5, 1 / 3, 3, 1, 1]])
    f = np.array([[1, 4, 1 / 2], [1 / 4, 1, 1 / 4], [2, 4, 1]])
    
    main(a)
    main(b)
    main(c)
    main(d)
    main(e)
    main(f)
 
**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         0.33333333 0.125     ]
 [3.         1.         0.33333333]
 [8.         3.         1.        ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.08199023 0.23644689 0.68156288]
判断矩阵对应的最大特征值为 3.00
大功告成！！！

**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         3.         6.        ]
 [0.33333333 1.         4.        ]
 [0.2        0.5        1.        ]] 一致性检验未通过，需要重新进行调整判断矩阵

**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         1.         3.        ]
 [1.         1.         3.        ]
 [0.33333333 0.33333333 1.        ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.42857143 0.42857143 0.14285714]
判断矩阵对应的最大特征值为 3.00
大功告成！！！

**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         3.         4.        ]
 [0.33333333 1.         1.        ]
 [0.25       1.         1.        ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.63274854 0.19239766 0.1748538 ]
判断矩阵对应的最大特征值为 3.01
大功告成！！！

**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         2.         7.         5.         5.        ]
 [0.5        1.         4.         3.         3.        ]
 [0.14285714 0.25       1.         0.5        0.33333333]
 [0.2        0.33333333 2.         1.         1.        ]
 [0.2        0.33333333 3.         1.         1.        ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.47439499 0.26228108 0.0544921  0.09853357 0.11029827]
判断矩阵对应的最大特征值为 5.07
大功告成！！！

**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.   4.   0.5 ]
 [0.25 1.   0.25]
 [2.   4.   1.  ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.34595035 0.11029711 0.54375254]
判断矩阵对应的最大特征值为 3.05
大功告成！！！
 
main(x)
 
**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.    0.125 0.2   0.5   0.125 0.2   0.5  ]
 [8.    1.    0.5   1.    0.5   0.5   1.   ]
 [5.    2.    1.    1.    0.5   1.    1.   ]
 [2.    1.    1.    1.    0.25  0.5   1.   ]
 [8.    2.    2.    4.    1.    0.5   1.   ]
 [5.    2.    1.    2.    2.    1.    0.5  ]
 [2.    1.    1.    1.    1.    2.    1.   ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.03787191 0.12641825 0.15144125 0.10278494 0.22816213 0.19300904
 0.16031248]
判断矩阵对应的最大特征值为 7.67
大功告成！！！





array([0.03787191, 0.12641825, 0.15144125, 0.10278494, 0.22816213,
       0.19300904, 0.16031248])
 
main(x2)
 
**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.         0.25       0.125     ]
 [4.         1.         0.33333333]
 [8.         3.         1.        ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.0738203  0.25718595 0.66899375]
判断矩阵对应的最大特征值为 3.02
大功告成！！！





array([0.0738203 , 0.25718595, 0.66899375])
 
3.3.1 直接将打分ok的excel表格读入并进行一致性检验以及权重的计算
 
import pandas as pd
df = pd.read_excel('data/层次分析法打分表.xlsx', sheet_name='Sheet2')
df
 
 
 
C21
C22
C23
C24
C25
C26
C27
C21
1
0.125
0.2
0.5
0.125
0.2
0.5
C22
8
1.000
0.5
1.0
0.500
0.5
1.0
C23
5
2.000
1.0
1.0
0.500
1.0
1.0
C24
2
1.000
1.0
1.0
0.250
0.5
1.0
C25
8
2.000
2.0
4.0
1.000
0.5
1.0
C26
5
2.000
1.0
2.0
2.000
1.0
0.5
C27
2
1.000
1.0
1.0
1.000
2.0
1.0
 
df_array = np.array(df)
df_array
 
array([[1.   , 0.125, 0.2  , 0.5  , 0.125, 0.2  , 0.5  ],
       [8.   , 1.   , 0.5  , 1.   , 0.5  , 0.5  , 1.   ],
       [5.   , 2.   , 1.   , 1.   , 0.5  , 1.   , 1.   ],
       [2.   , 1.   , 1.   , 1.   , 0.25 , 0.5  , 1.   ],
       [8.   , 2.   , 2.   , 4.   , 1.   , 0.5  , 1.   ],
       [5.   , 2.   , 1.   , 2.   , 2.   , 1.   , 0.5  ],
       [2.   , 1.   , 1.   , 1.   , 1.   , 2.   , 1.   ]])
 
main(df_array)
 
**************************************************
我是炫酷的分割线
--------------------------------------------------

矩阵 [[1.    0.125 0.2   0.5   0.125 0.2   0.5  ]
 [8.    1.    0.5   1.    0.5   0.5   1.   ]
 [5.    2.    1.    1.    0.5   1.    1.   ]
 [2.    1.    1.    1.    0.25  0.5   1.   ]
 [8.    2.    2.    4.    1.    0.5   1.   ]
 [5.    2.    1.    2.    2.    1.    0.5  ]
 [2.    1.    1.    1.    1.    2.    1.   ]] 一致性检验通过
判断矩阵对应的指标的权重为：[0.03787191 0.12641825 0.15144125 0.10278494 0.22816213 0.19300904
 0.16031248]
判断矩阵对应的最大特征值为 7.67
大功告成！！！





array([0.03787191, 0.12641825, 0.15144125, 0.10278494, 0.22816213,
       0.19300904, 0.16031248])
 
3.4 Excel实现
 
这个可以见附件上传数据，均为简单excel函数，近似求解特征值和特征向量，不难。
 
3.5 如何得到总权重
 
这个得看具体需求是否需要。
 
已经计算出二级指标对应权重
已经计算出二级指标下对应的三级指标对应权重
如果需要考虑三级指标的整体权重，把二级权重×三级权重即可！这样的目的就是所有指标的权重之和为1！
 
4 参考
 
https://wiki.mbalib.com/wiki/层次分析法
https://blog.csdn.net/jiangzhouyue/article/details/52926039
https://wenku.baidu.com/view/96cc92ac195f312b3069a54e.html
https://wenku.baidu.com/view/ea612a7c31b765ce05081473.html
 
5 附录：AHP层次分析法的Excel版本实现
 
注：一般实际业务场景中，用Excel版本的AHP会更加实用，上面的Python版本仅作为验证以及练习。原因如下：
 
Excel中一旦专家将分数打完之后，会出一个R.I结果，如果大于0.1，可以自行调整判断矩阵，直至符合条件为止
Excel进行操作易于专家打分以及结果汇总。
 
AHP层次分析法_Excel实现

问题背景描述
 某高校正在进行教师的评优工作，现应用层次分析法对待评教师的综合素质进行评价。整个层次结构分为三层，最高层即问题分析的总目标，要评选出优秀教师A；第二层是准则层，包括三种指标学识水平C1、科研能力C2、教学工作C3；第三层是方案层，即参加评优的教师，假设对五位候选教师P1、P2、P3、P4、P5进行评优，其中P2、P3、P4为任课教师，需要从学识水平、科研能力、教学工作三方面评估其综合素质，教师P5是科研人员，只需从学识水平、科研能力两方面衡量其综合素质，教师P1是行政人员，只需从学识水平和教学工作两方面衡量。
 三个评价指标的相对重要程度不同，并且各位教师在三个指标上表现不同，具体如下：科研能力指标比学识水平指标明显重要，教学工作指标比学识水平指标稍微重要，科研能力指标比教学工作指标稍微重要。在学识水平上，P1稍微高于P2，P1明显高于P3，P1比P4处于稍微高与明显高之间，P1强烈高于P5，P2稍微高于P3，P2比P4处于同样高与稍微高之间，P2明显高于P5，P3比P5处于同样高与稍微高之间，P4比P3处于同样高与稍微高之间，P4稍微高于P5；在科研能力上，P3强烈高于P2，P4稍微高于P2，P5明显高于P2，P3明显高于P4，P3比P5处于同样高与稍微高之间，P5稍微高于P4；在教学工作上，P1稍微高于P3，P1稍微高于P4，P2稍微高于P3，P2稍微高于P4，P1与P2水平相当，P3与P4水平相当。
 
import numpy as np  # Python本身没有处理矩阵的数据类型，因此需要使用附加的函数库。

"""
1. 读取csv文件
"""


def prin(path):
    tmp = np.loadtxt(path, dtype=np.str, delimiter=",")
    tmp = tmp.astype(float)  # 类型转换
    return tmp


"""
2. 方根法求单层元素相对重要性
"""


def ReImpo(F):
    n = np.shape(F)[0]  # F矩阵的行数，np.shape(F)[1]为列数
    W = np.zeros([1, n])  # 生成1行n列的0矩阵
    for i in range(n):
        t = 1
        for j in range(n):
            t = F[i, j] * t  # 累乘
        W[0, i] = t ** (1 / n)  # 开n次方根求Wi
    W = W / sum(W[0, :])  # 归一化
    return W.T


"""
3. 一致性检验
"""


def isConsist(F, RI):
    n = np.shape(F)[0]  # F矩阵的行数，np.shape(F)[1]为列数
    W = np.zeros([1, n])
    λmi = np.zeros([1, n])
    λmax = 0
    for i in range(n):
        t = 1
        for j in range(n):
            t = F[i, j] * t  # 累乘
        W[0, i] = t ** (1 / n)  # 开n次方根求Wi
    for i in range(n):
        temp = 0
        for j in range(n):
            temp = F[i, j] * W[0, j] + temp
        λmi[0, i] = temp / W[0, i]
        λmax = λmax + λmi[0, i] / n
    CI = (λmax - n) / (n - 1)
    CR = CI / RI
    if CR <= 0.1:
        return bool(1)
    else:
        return bool(0)


"""
4. 计算综合重要性
"""


def ComImpo(F12, F231, F232, F233):  # 综合重要性
    if isConsist(F12, 0.58) and isConsist(F231, 1.12) and isConsist(F232, 0.90) and isConsist(F233, 0.90):
        W12 = ReImpo(F12)
        W231 = ReImpo(F231)
        b = np.array([[0]])
        W232 = np.r_[b, ReImpo(F232)]  # np.r_是按列连接两个矩阵
        W233 = np.r_[ReImpo(F233), b]
        W23 = np.hstack([W231, W232, W233])  # np.hstack将参数元组的元素数组按水平方向进行叠加
    else:
        print("判断矩阵不通过一致性检验！")
        return 0
    n = len(W23)
    C = np.zeros([1, n])
    for i in range(n):
        t = W23[i, :]
        C[0, i] = sum((W12.T * t)[0])
    return C


def main():
    F1 = prin("F1.csv")
    F2 = prin("F2.csv")
    F3 = prin("F3.csv")
    F4 = prin("F4.csv")
    C = ComImpo(F1, F2, F3, F4)
    print("P1-P5五位教师综合推荐指数分别为：")
    for i in range(5):
        print(C[0, i])
    print("因此评价排序为：")
    print(np.argsort(-C) + 1)  # 将C中的元素从大到小排列，提取其对应的index(索引)


if __name__ == '__main__':
    main()

 
相对于总目标各指标间的相对重要性（三阶判断矩阵）
 
 各教师的学识水平比较（五阶判断矩阵）
 各教师的科研能力比较（四阶判断矩阵）
 各教师的教学工作比较（四阶判断矩阵）
 运行结果
 
 实验结果表明，对P1-P5五位教师综合素质进行评价排序由高到低为：P3,P5,P2,P1,P4。

AHP层次分析法(The analytic hierarchy process)是一种解决多目标复杂问题的定性和定量相结合进行计算决策权重的研究方法。该方法将定量分析与定性分析结合起来，用决策者的经验判断各衡量目标之间能否实现的标准之间的相对重要程度，并合理地给出每个决策方案的每个标准的权数，利用权数求出各方案的优劣次序，比较有效地应用于那些难以用定量方法解决的课题。
 
比如现在想选择一个最佳旅游景点，当前有三个选择标准（分别是景色，门票和交通），并且对应有三种选择方案。现通过旅游专家打分，希望结合三个选择标准，选出最佳方案（即最终决定去哪个景区旅游）。诸如此类问题即专家打分进行权重计算等，均可通过AHP层次分析法得到解决。
 
 
正如上述问题，专家可以对3个准则层标准（分别是景色，门票和交通）进行打分，得到3个选择标准对应的权重值；然后结合准则层得到的权重值，加上方案层的得分，最终选择出最佳方案。
 
 
特别提示
 
 
对于AHP层次分析法，即专家打分进行权重，专家打分需要遵循特殊的数据格式，即“判断矩阵”；
 
 
AHP层次分析法包括两个步骤，分别是权重计算和一致性检验（SPSSAU会默认输出）；