精华内容
下载资源
问答
  • 数学建模:层次分析法实例以及代码

    千次阅读 多人点赞 2020-11-22 22:06:09
    目录层次分析法的思想层次分析法步骤具体案例(市政工程项目建设决策)1.问题提出2.建立递阶层次结构3.构造判断矩阵(成对比较阵)并赋值4.层次单排序(计算权向量)与检验(一致性检验)计算权向量一致性检验5.层次总...

    博主联系方式:
    QQ:1540984562
    微信:wxid_nz49532kbh9u22 QQ交流群:892023501

    层次分析法的思想

    层次分析法的思想:将所有要分析的问题层次化
    根据问题的性质和所要到达的总目标,将问题分为不同的组成因素,并按照这些因素间的关联影响即其隶属关系,将因素按不同层次聚集组合,形成一个多层次分析结构模型
    最后,对问题进行优劣比较排序.

    层次分析法步骤

    1、找准各因素之间的隶属度关系,建立递阶层次结构
    2、构造判断矩阵,并赋值
    3、层次单排序(计算权向量)与检验(一致性检验)
    4、层次总排序(组合权向量)与检验(一致性检验)
    5、结果分析

    具体案例(市政工程项目建设决策)

    1.问题提出

    市政部门管理人员需要对修建一项市政工程项目进行决策,可选择的方案是修建通往旅游区的高速路(简称建高速路)或修建城区地铁(简称建地铁)。除了考虑经济效益外,还要考虑社会效益环境效益等因素,即是多准则决策问题,考虑运用层次分析法解决。

    2.建立递阶层次结构

    1、明确决策目标:“合理建设市政工程,使综合效益最高”。

    2、为了实现这一目标,需要考虑的主要准则有三个,即经济效益社会效益环境效益
    还必须考虑直接经济效益间接经济效益方便日常出行方便假日出行减少环境污染改善城市面貌等因素(准则),从相互关系上分析,这些因素隶属于主要准则,因此放在下一层次考虑,并且分属于不同准则。

    3、解决方案,即建高速路或建地铁,这两个因素作为措施层元素放在递阶层次结构的最下层。

    这样递阶层次就形成了:
    在这里插入图片描述

    3.构造判断矩阵(成对比较阵)并赋值

    1、构造判断矩阵的方法:
    每一个具有向下隶属关系的元素(被称作准则)作为判断矩阵的第一个元素(位于左上角),隶属于它的各个元素依次排列在其后的第一行第一列
    如下图所示:
    在这里插入图片描述
    2、如何对判断矩阵进行赋值:
    向填写人(专家)反复询问:针对判断矩阵的准则,其中两个元素两两比较哪个重要,重要多少,对重要性程度按1-9赋值。
    (可以类比模糊PID中的隶属程度,都是人为设定的,也是被人诟病的一个地方)
    在这里插入图片描述
    设填写后的判断矩阵为A=(aij)n×n,判断矩阵具有如下性质:

    (1) aij>0
    (2) aji=1/ aji
    (3) aii=1

    判断矩阵具有对称性,因此在填写时,通常先填写aii=1部分,然后再仅需判断及填写上三角形或下三角形的n(n-1)/2个元素就可以了。
    在特殊情况下,判断矩阵可以具有传递性,即满足等式:aij*ajk=aik .
    当上式对判断矩阵所有元素都成立时,则称该判断矩阵为一致性矩阵。
    对于上述的例子,可以构造出下面的判断矩阵:
    在这里插入图片描述

    4.层次单排序(计算权向量)与检验(一致性检验)

    计算权向量

    对于专家填写后的判断矩阵,利用一定数学方法进行层次排序。
    层次单排序是指每一个判断矩阵各因素针对其准则的相对权重,所以本质上是计算权向量。
    这里简要介绍和法:
    对于一致性判断矩阵,每一列归一化后就是相应的权重。
    对于非一致性判断矩阵,每一列归一化后近似其相应的权重,在对这n个列向量求取算术平均值作为最后的权重。

    公式: 在这里插入图片描述
    在层层排序中,要对判断矩阵进行一致性检验。判断矩阵可以具有传递性和一致性。一般情况下,并不要求判断矩阵严格满足这一性质。

    但从人类认识规律看,一个正确的判断矩阵重要性排序是有一定逻辑规律的,例如若A比B重要,B又比C重要,则从逻辑上讲,A应该比C明显重要,若两两比较时出现A比C重要的结果,则该判断矩阵违反了一致性准则,在逻辑上是不合理的。

    因此在实际中要求判断矩阵满足大体上的一致性,需进行一致性检验。只有通过检验,才能说明判断矩阵在逻辑上是合理的,才能继续对结果进行分析。

    一致性检验

    第一步,计算一致性指标CI
    在这里插入图片描述
    第二步,查表确定相应的平均随机一致性指标RI
    据判断矩阵不同阶数查下表,得到平均随机一致性指标RI:
    在这里插入图片描述
    第三步,计算一致性比例CR并进行判断:
    在这里插入图片描述
    当C.R.<0.1时,认为判断矩阵的一致性是可以接受的,C.R.>0.1时,认为判断矩阵不符合一致性要求,需要对该判断矩阵进行重新修正。

    图1
    图2
    可以看出,所有单排序的C.R.<0.1,认为每个判断矩阵的一致性都是可以接受的。

    5.层次总排序(组合权向量)与检验(一致性检验)

    总排序是指每一个判断矩阵各因素针对目标层(最上层)的相对权重。这一权重的计算采用从上而下的方法,逐层合成。
    文字性描述公式如下:
    在这里插入图片描述

    计算过程如下,更好理解过程:
    P(C1/A) = P(C1/B1) * P(B1/A) = 0.5 * 0.1429 = 0.07145
    CR(C1/A) = CR(C/B) * CR(B/A) = 0 * 0 = 0
    P(D1/A) = P(D1/C1) * P(C1/B1) * P(B1/A)
    + P(D1/C2) * P(C2/B1) * P(B1/A)
    + P(D1/C3) * P(C3/B2) * P(B2/A)
    + P(D1/C4) * P(C4/B2) * P(B2/A)
    + P(D1/C5) * P(C5/B3) * P(B3/A)
    + P(D1/C6) * P(C6/B3) * P(B3/A)
    =0.8333 * 0.5 * 0.1429
    +0.75 * 0.5 * 0.1429
    +0.1667 * 0.75 * 0.4286
    +0.8750 * 0.25 * 0.4286
    +0.1667 * 0.75 * 0.4286
    +0.8333 * 0.25 * 0.4286

    在这里插入图片描述

    6.结果分析

    从方案层总排序的结果看,建地铁(D2)的权重(0.6592)远远大于建高速路(D1)的权重(0.3408),因此,最终的决策方案是建地铁。
    根据层次排序过程分析决策思路:

    1、对于准则层B的3个因子,直接经济效益(B1)的权重最低(0.1429),社会效益(B2)和环境效益(B3)的权重都比较高(皆为0.4286),说明在决策中比较看重社会效益和环境效益
    2、对于不看重的经济效益,其影响的两个因子直接经济效益(C1)、间接带动效益(C2)单排序权重都是建高速路远远大于建地铁,对于比较看重的社会效益和环境效益,其影响的四个因子中有三个因子的单排序权重都是建地铁远远大于建高速路,由此可以推出,建地铁方案由于社会效益和环境效益较为突出,权重也会相对突出
    3、从准则层C总排序结果也可以看出,方便日常出行(C3)、减少环境污染(C5)是权重值较大的,而如果单独考虑这两个因素,方案排序都是建地铁远远大于建高速路。

    由此我们可以分析出决策思路:
    即决策比较看重的是社会效益和环境效益,不太看重经济效益;(总结准则层B)
    因此对于具体因子,方便日常出行和减少环境污染成为主要考虑因素,对于这两个因素,都是建地铁方案更佳,(总结准则层C)由此,最终的方案选择建地铁也就顺理成章了。

    7.层次分析法的优缺点

    优点:
    (1)系统性:层次分析把研究对象作为一个系统,按照分解、比较判断、综合的思维方式进行决策,成为继机理分析、统计分析之后发展起来的系统分析的重要工具。
    (2)实用性:层次分析把定性和定量方法结合起来,能处理许多许多用传统的最优化技术无法着手的实际问题,应用范围很广。同时,这种方法将决策者和决策分析者相互沟通,决策者甚至可以直接应用它,这就增加了决策者的了解和掌握。
    (3)简洁性:具有中等文化程度的人即可了解层次分析的基本原理和掌握它的基本步骤,计算也非常简便,并且所得的结果简单明确,容易为决策者了解和掌握。

    缺点:囿旧:只能从原有方案中选优,不能生成新方案;粗略:它的比较、判断直到结果都是粗糙的,不适于精度要求很高的问题;主观:从建立层次结构模型到给出成对比较矩阵,人的主观因素的作用很大,这就使得决策结果可能难以为众人接受。当然,采取专家群体判断的办法是克服这个缺点的一种途径。

    层次分析法的代码实现(matlab)

    disp('请输入判断矩阵A(n阶)');
    A=input('A=');
    [n,n]=size(A);
    x=ones(n,100);
    y=ones(n,100);
    m=zeros(1,100);
    m(1)=max(x(:,1));
    y(:,1)=x(:,1);
    x(:,2)=A*y(:,1);
    m(2)=max(x(:,2));
    y(:,2)=x(:,2)/m(2);
    p=0.0001;i=2;k=abs(m(2)-m(1));
    while  k>p
      i=i+1;
      x(:,i)=A*y(:,i-1);
      m(i)=max(x(:,i));
      y(:,i)=x(:,i)/m(i);
      k=abs(m(i)-m(i-1));
    end
    a=sum(y(:,i));
    w=y(:,i)/a;
    t=m(i);
    disp(w);disp(t);
             %以下是一致性检验
    CI=(t-n)/(n-1);RI=[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];
    CR=CI/RI(n);
    if CR<0.10
        disp('此矩阵的一致性可以接受!');
        disp('CI=');disp(CI);
        disp('CR=');disp(CR);
    end
    

    使用示例:
    将上面代码保存名为test1,并在点运行的时候添加到路径;
    输入的A矩阵是要以向量的形式输入的;
    之后按下回车即可,可以看到和之前的第4步得到的结果是一样的。
    在这里插入图片描述
    通过不断的使用这个式子计算相应矩阵(准则层B到准则层C、准则层C到方案层D)的权向量,最后可以得到最终的结果。
    简单的修改上面的程序,传入参数为矩阵,免得每次都要打。

    function w= test1(A)
    % disp('请输入判断矩阵A(n阶)');
    % A=input('A=');
    [n,n]=size(A);
    x=ones(n,100);
    y=ones(n,100);
    m=zeros(1,100);
    m(1)=max(x(:,1));
    y(:,1)=x(:,1);
    x(:,2)=A*y(:,1);
    m(2)=max(x(:,2));
    y(:,2)=x(:,2)/m(2);
    p=0.0001;i=2;k=abs(m(2)-m(1));
    while  k>p
      i=i+1;
      x(:,i)=A*y(:,i-1);
      m(i)=max(x(:,i));
      y(:,i)=x(:,i)/m(i);
      k=abs(m(i)-m(i-1));
    end
    a=sum(y(:,i));
    w=y(:,i)/a;
    t=m(i);
    disp(w);disp(t);
             %以下是一致性检验
    CI=(t-n)/(n-1);RI=[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];
    CR=CI/RI(n);
    if CR<0.10
        disp('此矩阵的一致性可以接受!');
        disp('CI=');disp(CI);
        disp('CR=');disp(CR);
    end
    

    输入:

    Array1=[1 1/3 1/3;3 1 1;3 1 1];
    Array2=[1 1;1 1];
    Array3=[1 3;1/3 1];
    Array4=[1 3;1/3 1];
    Array5=[1 5;1/5 1];
    Array6=[1 3;1/3 1];
    Array7=[1 1/5;5 1];
    Array8=[1 7;1/7 1];
    Array9=[1 1/5;5 1];
    Array10=[1 1/3;7 1];
    
    A=test1(Array1);
    B1=test1(Array2);
    B2=test1(Array3); 
    B3=test1(Array4);
    C1=test1(Array5);
    C2=test1(Array6);
    C3=test1(Array7);
    C4=test1(Array8);
    C5=test1(Array9);
    C6=test1(Array10);
    

    得到相应的矩阵:
    在这里插入图片描述

    展开全文
  • 乌龟和兔子 (极限思想层次不够) 那个问题,先假设时间可以无限细分这个错误的命题存在,那一个个时间节点累积起来是一个等比数列,也是有极限的,从这个角度看,也不是永远追不上。只是无限接近那个总的时间和...

    乌龟和兔子 (极限思想,层次不够)

    那个问题,先假设时间可以无限细分这个错误的命题存在,那一个个时间节点累积起来是一个等比数列,也是有极限的,从这个角度看,也不是永远追不上。只是无限接近那个总的时间和,在这里可以说通过文法的错误来迷惑观察者。

    展开全文
  • Android组件设计思想

    万次下载 热门讨论 2013-10-23 01:11:07
    Android应用开发的哲学是把一切...这一节讲Android组件化设计的背景、理念、原则,以及Android在OS级别上提供的组件化支持,其中还会包含一个实验来验证这种组件化设计思想,可以对Android系统有一个高层次的抽象理解。
  • AHP层次分析法

    万次阅读 多人点赞 2014-02-21 01:07:12
    在比赛中,我们运用了层次分析法(AHPAnalytic Hierarchy Process)进行建模,好不容易理解了这一方法的思想,在自己的博客里记录一下,希望可以帮助初次接触层次分析法的人,更快地理解这一的整体思想,也利于...

    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.,这样构造一个矩阵,再用之前的一致性矩阵的方法就可以求出一个权重,然后相对应因素(这里是工作环境)所拥有的权值就可以按这个权重比例分配给不同候选物或人。

     

    其他因素同理

     

     

    至此两个问题就都得到了解决

    最终将每个候选物、人从不同因素获得的权值求和,就可以得到不同候选对于目标层的权值大小,继而可以根据值的大小,来选出优劣

     

    对于第一部分的总结:

     

    • 通过对层次分析法的基本了解,不难发现层次分析法对人们的思维过程进行了加工整理,提出了一套系统分析问题的方法,为科学管理和决策提供了较有说服力的依据。 

     

    • 但很明显的缺点是,整个分析过程似乎都是依赖于人的主观判断思维,一来不够客观,二来两两比较全部人为完成,还是非常耗费精力的,尤其是当候选方案比较多的时候

     

     

     

    文章的第二部分:


    层次分析法的变形应用(也可能本来就是这样用的,只不过参考书上没这样说,外语
    论文没细看)解决最优教练选择问题

     

    目标:选最优教练

     

    准则:  

     

     

    1. 职业生涯所带队伍的胜率      
    2. 职业生涯所带队伍的胜场            
    3. 从教时长(年)          
    4. 职业生涯所带队伍获奖状况(化成分数)

     

      

    候选:  众多教练

     

    准则层比较矩阵获得

     

     

    • 准则层的比较矩阵好构造 ,作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));
    
        }
    }
    

     

     

    展开全文
  • 聚类算法——python实现层次聚类(AGNES)

    万次阅读 多人点赞 2017-05-15 20:39:35
    算法思想层次聚类是在不同层次上对数据进行划分,从而形成树状的聚类结构。 AGNES算法是自底向上的层次聚类算法。开始时将数据集中的每个样本初始化为一个簇,然后找到距离最近的两个簇,将他们合并,不断重复这个...

    算法思想

    层次聚类是在不同层次上对数据进行划分,从而形成树状的聚类结构。
    AGNES算法是自底向上的层次聚类算法。开始时将数据集中的每个样本初始化为一个簇,然后找到距离最近的两个簇,将他们合并,不断重复这个过程,直达到到预设的聚类数目为止。
    计算距离的三个公式:
    这里写图片描述
    这里写图片描述
    这里写图片描述
    AGNES算法根据上面个三个不同的公式,相应的被称为均链接,单链接和全链接。
    算法步骤如下:

    1. 将数据集中的每个样本初始化为一个簇,并放入集合C中。计算任意两个集合之间的距离,并存到M中。
    2. 设置当前聚类数目q = m。
    3. 当q大于k时执行如下步骤:
      3.1找到距离最近的两个集合Ci和Cj, 将Ci和Cj合并。并赋值给Ci。
      3.2在集合C中将Cj删除,更新Cj+1到Cq的下标。
      3.3删除M的第j行和第j列。更新M的第i行和第i列。
      3.4q = q-1
    4. 返回聚类集合C

    python实现算法

     #-*- coding:utf-8 -*-
    
    import math
    import pylab as pl
    
    #数据集:每三个是一组分别是西瓜的编号,密度,含糖量
    data = """
    1,0.697,0.46,2,0.774,0.376,3,0.634,0.264,4,0.608,0.318,5,0.556,0.215,
    6,0.403,0.237,7,0.481,0.149,8,0.437,0.211,9,0.666,0.091,10,0.243,0.267,
    11,0.245,0.057,12,0.343,0.099,13,0.639,0.161,14,0.657,0.198,15,0.36,0.37,
    16,0.593,0.042,17,0.719,0.103,18,0.359,0.188,19,0.339,0.241,20,0.282,0.257,
    21,0.748,0.232,22,0.714,0.346,23,0.483,0.312,24,0.478,0.437,25,0.525,0.369,
    26,0.751,0.489,27,0.532,0.472,28,0.473,0.376,29,0.725,0.445,30,0.446,0.459"""
    
    #数据处理 dataset是30个样本(密度,含糖量)的列表
    a = data.split(',')
    dataset = [(float(a[i]), float(a[i+1])) for i in range(1, len(a)-1, 3)]
    
    
    
    #计算欧几里得距离,a,b分别为两个元组
    def dist(a, b):
        return math.sqrt(math.pow(a[0]-b[0], 2)+math.pow(a[1]-b[1], 2))
    
    #dist_min
    def dist_min(Ci, Cj):
        return min(dist(i, j) for i in Ci for j in Cj)
    #dist_max
    def dist_max(Ci, Cj):
        return max(dist(i, j) for i in Ci for j in Cj)
    #dist_avg
    def dist_avg(Ci, Cj):
        return sum(dist(i, j) for i in Ci for j in Cj)/(len(Ci)*len(Cj))
    
    #找到距离最小的下标
    def find_Min(M):
        min = 1000
        x = 0; y = 0
        for i in range(len(M)):
            for j in range(len(M[i])):
                if i != j and M[i][j] < min:
                    min = M[i][j];x = i; y = j
        return (x, y, min)
    
    #算法模型:
    def AGNES(dataset, dist, k):
        #初始化C和M
        C = [];M = []
        for i in dataset:
            Ci = []
            Ci.append(i)
            C.append(Ci)
        for i in C:
            Mi = []
            for j in C:
                Mi.append(dist(i, j))
            M.append(Mi)
        q = len(dataset)
        #合并更新
        while q > k:
            x, y, min = find_Min(M)
            C[x].extend(C[y])
            C.remove(C[y])
            M = []
            for i in C:
                Mi = []
                for j in C:
                    Mi.append(dist(i, j))
                M.append(Mi)
            q -= 1
        return C
    #画图
    def draw(C):
        colValue = ['r', 'y', 'g', 'b', 'c', 'k', 'm']
        for i in range(len(C)):
            coo_X = []    #x坐标列表
            coo_Y = []    #y坐标列表
            for j in range(len(C[i])):
                coo_X.append(C[i][j][0])
                coo_Y.append(C[i][j][1])
            pl.scatter(coo_X, coo_Y, marker='x', color=colValue[i%len(colValue)], label=i)
    
        pl.legend(loc='upper right')
        pl.show()
    
    C = AGNES(dataset, dist_avg, 3)
    draw(C)
    
    
    
    

    这是采用dist_avg函数运行的结果图。
    这里写图片描述
    这里写图片描述

    展开全文
  • 层次分析法

    万次阅读 2015-06-11 18:11:53
    层次分析法(Analytic Hierarchy Process,简称AHP)是将与决策总是有关的元素分解成目标、准则、方案等层次,在此基础之上进行定性和定量分析的决策方法。该方法是美国运筹学家匹茨堡大学教授萨蒂于20世纪70年代初...
  • 采用二叉链表结构实现二叉树,并以递归遍历思想实现二叉树的创建、二叉树的遍历(先序、中序、后序和层次遍历)、二叉树叶子节点统计、二叉树深度统计的算法;同时,结合课件和实例代码,实现二叉树的中序非递归遍历...
  • 聚类算法之层次聚类

    万次阅读 多人点赞 2018-04-30 01:13:32
    一、原型聚类和层次聚类原型聚类也称基于原型的聚类(prototype-based clustering),这类算法假设聚类结构能够通过一组原型刻画,先对原型进行初始化,然后对原型进行迭代更新求解。采用不同的原型表示、不同的求解...
  • 机器学习之层次聚类

    千次阅读 2017-03-12 20:12:15
    层次聚类聚类是将样本进行归类形成K个簇,层次聚类是其中的一种方法。它将数据组成一棵聚类树,过程可以是凝聚形式或分裂形式。核心思想凝聚是一开始将每个样本当做一个聚类,接着通过计算将距离最近的两个聚类合并...
  • 二叉树层次遍历算法——C/C++

    万次阅读 多人点赞 2019-06-16 00:32:47
    1、算法思想 用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。 在进行层次遍历的时候,设置一个队列结构,遍历从二叉树的根节点开始,首先将根节点指针入队列,然后从队头取出一个元素,每取一个元素,...
  • 模板层次结构页面 首先,打开一个网站 ...这个结构的核心:简单来说就是备胎的思想。 在这里,我随意点击一个模板文件: template hierarchy xuhss.com01 - WordPress模板层次02:模板层次结构和原理 ...
  • 树的层次遍历

    万次阅读 多人点赞 2019-02-15 14:44:47
    二叉树的前序、中序、后序遍历我想大家应该都很熟悉了,那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈(递归的过程也就是一个栈),层次遍历需要借助队列这个数据结构。 层次...
  • 机器学习实战——层次聚类算法1 层次聚类概述2 sklearn中的实现 1 层次聚类概述 层次聚类试图在不同层次对数据集...的思想,先将所有的样本都看作是同一个簇,然后通过迭代将簇划分为更小的簇,直到每个簇中只有一...
  • 层次聚类算法

    千次阅读 2018-09-04 15:08:58
    首先介绍聚类中的层次聚类算法。层次法又分为凝聚的层次聚类和分裂的层次聚类。  凝聚的方法:也称自底向上的方法,首先将每个对象作为单独的一个聚类,然后根据性质和规则相继地合并相近的类,直到所有的对象都...
  • 1.层次遍历 算法思想:建立一个循环队列,先将二叉树头结点如队列,然后出队列,访问该结点,若该结点有左子树则左结点队列,如果有右子树入队列,然后出队访问,直到为空 void level(BTNode *p) { BTNode *...
  • 【AHP】层次分析法 | 过程解读 案例实践

    千次阅读 多人点赞 2020-08-20 19:56:21
    AHP 基本思想 [1] AHP 把复杂的问题分解为各个组成因素,又将这些因素按支配关系分组形成地递阶层次结构。通过两两比较的方式确定方式确定层次中诸因素的相对重要性。然后综合有人员的判断,确定备选方案相对重要
  • 云计算技术层次

    千次阅读 2012-05-10 08:22:48
    而云计算的技术层次主要从系统属性和设计思想角度来说明云,是对软硬件资源在云计算技术中所充当角色的说明。从云计算技术角度来分,云计算大约有4部分构成:物理资源、虚拟化资源、中间件管理部分和服务接口,如下...
  • OOP编程思想

    万次阅读 多人点赞 2018-07-31 19:29:53
    而每继承性是对具有层次关系的类的属性和操作进行共享的一种方式。所谓面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解、刻画客观世界和设计、构建相应的软件系统。 oop的基本思想:...
  • 层次聚类(HIERARCHICAL CLUSTERING)是聚类算法的一种,通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树。在聚类树中,不同类别的原始数据点是树的最低层,树的顶层是一个聚类的根节点。创建聚类树有...
  • 数学建模之层次分析法(AHP)

    万次阅读 多人点赞 2018-09-05 12:03:08
    层次分析法(Analytic Hierarchy Process) AHP是对一些较为复杂的,较为模糊的问题作出决策的简易方法,它特别适用于那些难以完全定量分析的问题。 它是美国运筹学家T.L.Saaty教授于上世纪70年代初期提出的一种...
  • 二叉树层次遍历算法

    千次阅读 2020-08-27 01:23:39
    层次遍历 其实记住以上的输出顺序还是非常简单的。首先要明白,左节点一定先比右节点输出! 那么就很好理解了,那么那些所谓的前序、中序、后序而言是针对根节点的相对位置命名的。 例如前序遍历,则就是根节点是最...
  • 层次分析法(AHP)——matlab代码实现

    万次阅读 多人点赞 2019-04-17 10:02:45
    层次分析法(AHP)的主要思想是根据研究对象的性质将要求达到的目标分解为多个组成因素,并按组成因素间的相互关系,将其层次化,组成一个层次结构模型,然后按层分析,最终获得最高层的重要性权值。层次分析法把一...
  • 层次聚类——linkage方法

    万次阅读 2017-12-26 20:17:42
    最近在使用层次聚类时,简单了解了一下合并类簇时所使用的几种linkage方法,在这里作一下简单的总结。  1963年,Ward J H提出了使用离差平方(Error Sum of Square)和或者说是信息缺失量作为目标函数的思想来...
  • 存储器层次结构

    千次阅读 2009-12-18 20:36:00
    VIRTUAL MEMORY (distributed file system,Web servers) 存储器层次结构中心思想:对于每一层,位于上层的更快更小的存储设备作为位于下层更大更慢的存储设备的缓存。这个中心思想是由程序的局部性原
  • 层次遍历树

    千次阅读 2019-03-11 18:13:24
    根据层次遍历得到的结果应该是: A B C D E F G H I J 自定义的树其孩子使用的是链表存储;存储的结果,定义如下 public class TreeNode&lt;T&gt; { private T key; public TreeNode&lt;T&gt; ...
  • 四、(1)层次聚类

    2019-06-07 20:33:42
    在社会学领域,一般通过给定网络的拓扑结构定义网络节点间的相似性或距离,然后采用单连接层次聚类或全连接层次聚类将网络节点组成一个树状图层次结构。其中,树的叶节点表示网络节点,非叶节点一般由相似或距离接近...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 201,893
精华内容 80,757
关键字:

思想层次