精华内容
下载资源
问答
  • 层次总排序的计算方法
    万次阅读
    2019-06-10 16:58:47

    AHP方法
    AHP算法计算层次权重其基本步骤为将问题分解为不同的组成因素,按照因素间的相互关系或者隶属关系将因素按不同因素聚集集合,形成一个多层次的分析结构模型,并由此构建判断(或成对比较)矩阵,依据判断矩阵对层次进行单排序并检验是否通过一致性检验,最后计算某一层次所有因素对于最高层(总目标)相对重要性的权值,称为层次总排序。其流程图如图所示:

    图# AHP算法计算流程
    1.建立层次结构模型
    将决策的目标、考虑的因素(决策准则)和决策对象按它们之间的相互关系分为最高层、中间层和最低层,绘出层次结构图。在本例中,决策的目标是计算各分割产品的合理定价,考虑的因素应为市场喜好程度,决策对象为各分割产品。
    2.构造判断矩阵
    在确定各层次各因素之间的权重时,如果只是定性的结果,则常常不容易被别人接受,因而Santy等人提出一致矩阵法,即不把所有因素放在一起比较,而是两两相互比较,对此时采用相对尺度,以尽可能减少性质不同的诸因素相互比较的困难,以提高准确度。如对某一准则,对其下的各方案进行两两对比,并按其重要性程度评定等级。 为要素 与要素j重要性比较结果。按两两比较结果构成的矩阵称作判断矩阵。判断矩阵具有如下性质:
    a_ij=1/a_ji
    构造判断矩阵时一般通过两两比对进行确认,一般按照下表比例标度进行确认标度值:
    因素i比因素j 量化值
    同等重要 1
    稍微重要 3
    较强重要 5
    强烈重要 7
    极端重要 9
    两相邻判断的中间值 2,4,6,8
    3.层次单排序及其一致性检验
    对应于判断矩阵最大特征根 的特征向量w,w经归一化后记为W。W的元素为同一层次因素对于上一层次因素某因素相对重要性的排序权值,这一过程称为层次单排序。能否确认层次单排序,则需要进行一致性检验,定义一致性指标为:
    CI= ((λ-n))/(n-1)
    式中:λ为判断矩阵特征向量;n为因素数量
    CI=0,有完全的一致性;CI 接近于0,有满意的一致性;CI 越大,不一致越严重。为衡量CI的大小,引入随机一致性指标RI:
    RI= (〖CI〗_1+〖CI〗_2+⋯+〖CI〗_n)/n
    其中,随机一致性指标RI和判断矩阵的阶数有关,一般情况下,矩阵阶数越大,则出现一致性随机偏离的可能性也越大,本例因素数量为24,查表得RI取值1.6497。
    考虑到一致性的偏离可能是由于随机原因造成的,因此在检验判断矩阵是否具有满意的一致性时,还需将CI和随机一致性指标RI进行比较,得出检验系数CR,公式如下:
    CR = CI/RI
    一般,如果CR<0.1 ,则认为该判断矩阵通过一致性检验,否则就不具有满意一致性。
    4.层次总排序及其一致性检验
    计算某一层次所有因素对于最高层(总目标)相对重要性的权值,称为层次总排序。
    #计算各产品的定价权重
    a = [];#a为判断矩阵
    n = len(a)
    b = []
    for i in range(24):
    b.append(a/a[i])

    B = np.transpose(b)#转置
    value,V = np.linalg.eig(B)#value特征值,V为特征向量
    value_max = np.argmax(value)#寻找最大的特征值的索引
    w1 = V[:,value_max]
    
    for i in w1:
    	w = w1/sum(i)
    W = np.transpose(w) #获得权重矩阵
    #一致性检验
    CI = (value[value_max]-n)/(n-1)
    RI = 1.6793 #查表获得n个阶数下的一致性指标值
    CR = CI/RI
    if CR < 0.1:
    	print('通过一致性检验!\n')
    else:
    	print('需重新赋值一致性不被接受!\n')
    

    熵值法
    1、基本原理
    熵值法是指用来判断某个指标的离散程度的数学方法。离散程度越大,对该指标对综合评价的影响越大。可以用熵值判断某个指标的离散程度。可根据各项指标的变异程度,利用信息熵这个工具,计算出各个指标的权重,为多指标综合评价提供依据。
    2、算法步骤
    (1)选取n个层次,m个指标,则x_ij为第i个层次的第j个指标的数值;(i=1,2,3…,n; j = 1,2,3…m)

    (2)指标的归一化处理:异质指标的同质化
    (3)计算第j项指标下第i个层次占该指标的比重:

    (4)计算第j项指标的熵值

    (5)计算信息熵冗余度:

    (6)计算各项指标的权重值

    更多相关内容
  • 论文研究- 对AHP层次总排序方法的扩展.pdf, 层次分析法是将定性问题进行定量分析的一种简单而实用的决策方法。基本过程是:对所分析的问题建立层次模型,然后将一个层次的各因素相对于上一层次的各准则(或目标)进行...
  • 论文研究-层次分析法中排序权数的计算方法.pdf, 本文介绍层次分析法中对于完整及残缺评判矩阵排序权数的几种计算方法以及改进措施,并对多层次综合评判作了一些探讨和分析。
  • 介绍层次分析法的基本概念,同时也分析了层次分析法权重的计算方法及应用,层次分析法的计算方法有四种方法:几何平均法、算术平均法、特征向量法、最小二乘法,以往的文献利用层次分析法解决实际问题时,都是采用其中的...
  • AHP,即层次分析法(Analytic Hierarchy Process,AHP)是一种系统化的、层次化的多目标综合评价方法。在评价对象的待评价属性复杂多样,结构各异,难以量化的情况下AHP层次分析法也能发挥作用。

    目录

    1.层次分析法原理介绍

    2.层次分析法建模步骤

    3.案例分析

    3.1 题目简述

    3.2 确定评价指标,建立层次关系

    3.3 构造判断矩阵

    3.3.1 标度定义

    3.3.2 构造判断矩阵

     3.4 一致性检验

    3.5 层次总排序

    4.代码实现


    1.层次分析法原理介绍

            关于层次分析法的具体原理即详细的步骤以及有很多人发布,可自行搜索查看,以下链接为个人认为较好的两篇:数学建模方法——层次分析法(AHP)_Learning-Deep-CSDN博客_层次分析法列向量归一化计算0. 层次分析法简介层次分析法(Analytic Hierarchy Process,简称AHP)主要是对于定性的决策问题进行定量化分析的方法。举个例子,在日常生活中,我们经常需要进行感性的判断,比如报高考志愿,感觉清华北大都很好,到底要报哪个;再比如去市场买菜,到底是买青椒做青椒炒鸡蛋,还是买黄瓜做黄瓜炒鸡蛋;再比如想去出游,到底是去公园A还是公园B。上面提到的这些问题,都是决策,也叫做评价类...https://blog.csdn.net/limiyudianzi/article/details/103389880?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-103389880.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

    【AHP】层次分析法 | 过程解读 案例实践_Fxtack的博客-CSDN博客_ahp分析法完整案例AHP 层次分析法一. AHP 层次分析法介绍AHP 层次分析法简介AHP,即层次分析法(Analytic Hierarchy Process,AHP)是一种系统化的、层次化的多目标综合评价方法。在评价对象的待评价属性复杂多样,结构各异,难以量化的情况下AHP层次分析法也能发挥作用。AHP 基本思想 [1]AHP 把复杂的问题分解为各个组成因素,又将这些因素按支配关系分组形成地递阶层次结构。通过两两比较的方式确定方式确定层次中诸因素的相对重要性。然后综合有人员的判断,确定备选方案相对重要https://blog.csdn.net/weixin_43095238/article/details/108055579?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-2-108055579.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

    2.层次分析法建模步骤

    3.案例分析

    3.1 题目简述

            假定现需要购置一批冰箱,由于市场上冰箱种类参差不齐,其性能及性价比也存在很大差异,现有一批冰箱待选择,请考虑冰箱的容积、功耗、外观、噪声、寿命、价格、保修时间等因素,建立模型,确定性价比最高的购买方案。

    量化后冰箱参数:

    以冰箱A为基准,若该项性能优于A则其值加1,且每优一级都加1,反之亦然。

    容积功耗外观噪声寿命价格保修时间
    A5555555
    B6838797
    C24828510

    3.2 确定评价指标,建立层次关系

    3.3 构造判断矩阵

    3.3.1 标度定义

    标度含义
    1两个要素相比,重要性相同
    3两要素相比,前者比后者稍微重要或有优势
    5两要素相比,前者比后者比较重要或有优势
    7两要素相比,前者比后者十分重要或有优势
    9两要素相比,前者比后者绝对重要或有优势
    2,4,6,8为上述标度之间的中间值

    若要描述后者与前者比较,则用倒数为标度。例如 1/3 描述的是,后者比前者稍微重要。 

    3.3.2 构造判断矩阵

    属性容积功耗外观噪声寿命价格保修时间
    容积

    1

    3

    2

    1/2

    1/3

    1/6

    1/2

    功耗

    1/3

    1

    5

    1

    1/3

    1/2

    1/2

    外观

    1/2

    1/5

    1

    1/3

    1/3

    1/4

    1/3

    噪声

    2

    1

    3

    1

    1/3

    1/3

    1/3

    寿命

    3

    3

    3

    3

    1

    1/2

    1/2

    价格

    6

    2

    4

    3

    1

    1

    3

    保修时间

    2

    2

    3

    3

    2

    1/3

    1

     3.4 一致性检验

    具体的计算方法见推荐阅读的两篇文章。

    经过计算得到C.R=0,025<0.1,故一致性检验成功。

     得到七种属性的权值如下:

    属性容积功耗外观噪声寿命价格保修时间
    权值0.090.100.050.100.180.290.19

    3.5 层次总排序

    属性容积功耗外观噪声寿命价格保修时间评分
    权值0.090.100.050.100.180.290.19
    A55555555
    B68387977.49
    C248285105.97

     由此可见评分:B>C>A。故冰箱B对顾客来说性价比最高。

    4.代码实现

    package AHP;
    
    import java.util.Scanner;
    
    public class AHP {
    	public static void main(String[] args) {
    		System.out.println("输入矩阵阶数:");
    		Scanner scanner = new Scanner(System.in);
    		int n = scanner.nextInt();
    		System.out.println("按行输入:");
    		double d[][] = new double[n][n];
    		double temp[][] = new double[n][n];
    		for (int i = 0; i < n; i++) { 
    			for (int j = 0; j < n; j++) {
    				double sToD = SToD(scanner.next());
    				d[i][j] = sToD;
    				temp[i][j] = sToD;
    			}
    		}
    
    		System.out.println("以下是判断矩阵");
    		// 得到判断矩阵
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				System.out.printf("%.2f\t", d[i][j]);
    			}
    			System.out.println();
    		}
     
    		// 1.对判断矩阵进行求和
    		System.out.println("列相加结果w1");
     
    		double w1[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w1[i] = w1[i] + d[j][i];
    			}
    			System.out.printf("%.2f\t", w1[i]);
    		}
     
    		// 2.相除
    		System.out.println();
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				d[i][j] = d[i][j] / w1[j];
    			}
    		}
    		System.out.println("和积法第一步求出的结果d(即对列向量归一化):");
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				System.out.printf("%.2f\t", d[i][j]);
    			}
    			System.out.println();
    		}
     
    		System.out.println("对第一步求出的结果进行 行相加");
     
    		System.out.println("行相加结果w2:");
     
    		double w2[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w2[i] = w2[i] + d[i][j];
    			}
    			System.out.printf("\t%.2f\n", w2[i]);
    		}
     
    		System.out.println("特征向量求解第一步 : 将上面的行相加的所有结果相加sum:");
    		double sum = 0.0;
    		for (int i = 0; i < n; i++) {
    			sum += w2[i];
    		}
    		System.out.printf("结果为sum = \t%.2f\n", sum);
     
    		System.out.println("将行结果与 sum 相除 得出结果为w3:  ");
    		double w3[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			w3[i] = w2[i] / sum;
    			System.out.printf("\t%.2f\n", w3[i]);
    		}
     
    		System.out.println();
    		System.out.println("************************************************");
    		System.out.println("用和积法计算其最大特征向量为(即权重):W = ");
    		// 以下是校验
    		System.out.printf("(");
    		for (int i = 0; i < n; i++) {
    			System.out.printf("%.2f ,", w3[i]);
    		}
    		System.out.printf(")");
     
    		System.out.print("\nBW(w4) = ");//BW即行相加结果
    		double w4[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w4[i] = w4[i] + temp[i][j] * w3[j];
    			}
    			System.out.printf("%.5f \t", w4[i]);
    		}
    		System.out.println("\n----------------------------------------");
    		double sum2 = 0.0;
    		for (int i = 0; i < n; i++) {
    			sum2 = sum2 + w4[i];
    		}
    		System.out.printf("得到最大特征值sum2:\t %.2f\n", sum2);
    		System.out.println("************************************************");
    		System.out.println("最大的特征向量为 :  ");
     
    		double result = 0.0;
    		for (int i = 0; i < n; i++) {
    			result = result + w4[i] / (6 * w3[i]);
    		}
    		System.out.printf(" %.2f \n", result);
     
    		System.out.println("\n判断矩阵一致性指标C.I.(Consistency Index)");
    		double CI = (result - n) / (n - 1);
    		System.out.printf(" %.2f \n", CI);
     
    		System.out.println("随机一致性比率C.R.(Consistency Ratio)");
     
    		/*
    		 * 
    		 n  1  2  3  	4  		5	  6	  7		  8		 9	  10	  11
    		RI  0  0  0.58  0.90  1.12  1.24  1.36  1.41  1.45  1.49  1.51 
    		一般,当一致性比率 <0.1 时
    		的不一致程度在容许范围之内,可用其归一化特征向量
    		作为权向量,否则要重新构造成对比较矩阵,对  加
    		以调整
    		 */
    		double RI = 0.0;
    		switch (n) {
    		case 0:
    			RI=0;
    			break;
    		case 1:
    			RI=0;
    			break;
    		case 2:
    			RI=0;
    			break;
    		case 3:
    			RI=0.58;
    			break;
    		case 4:
    			RI=0.90;
    			break;
    		case 5:
    			RI=1.12;
    			break;
    		case 6:
    			RI=1.24;
    			break;
    		case 7:
    			RI=1.36;
    			break;
     
    		default:
    			break;
    		}
    		double CR=CI / RI;
    		if(CR<0.1) {
    			System.out.printf("一致性检验成功!  C.R =  %.2f \n", CR);
    		}
    		else
    			System.out.printf("一致性检验失败!  C.R =  %.2f \n", CR);
    		
    		
    		scanner.close();
    	}
     
    	public static double SToD(String s) {
    		String[] p = s.split("/");
    		if (p.length > 1) {
    			return Double.parseDouble(p[0]) / Double.parseDouble(p[1]);
    		}
    		return Double.parseDouble(s);
    	}
    }
    
    

    展开全文
  • 论文研究-计算层次分析法中排序权值的加速遗传算法.pdf, 为处理 AHP中判断矩阵的一致性问题 ,直接从判断矩阵的定义出发 ,提出用加速遗传算法同时计算 AHP中各要素的排序...
  • 针对进行输电网规划时难以量化各指标主观权重与客观权重的问题,提出了一种将改进层次分析法、基于指标相关性的指标权重确定(CRITIC)法和逼近理想解排序法(TOPSIS)相结合的输电网规划方案评价方法。该方法首先分别...
  • AHP方法计算权重.pdf

    2019-09-11 16:58:34
    AHP层次分析法——一致性检验以及权重计算层次排序以及层次总排序一致性检验说明文档。详细,注意细节。文件最后到第二行应该是B3应该是B2。
  • 线性加权法的适用条件是各评价指标之间相互独立, 这样就可以利用多元线性回归方法来得到各指标对应的系数。 举个例子:所评价的对象是股票, 已知一些股票的各个指标以及这些股票的历史表现,其中最后一列标记为 1...

    (通过MATLAB实现)

    1.线性加权法

            线性加权法的适用条件是各评价指标之间相互独立, 这样就可以利用多元线性回归方法来得到各指标对应的系数。

            举个例子:所评价的对象是股票, 已知一些股票的各个指标以及这些股票的历史表现,其中最后一列标记为 1 的表示为上涨股票,标为 0 的表现为一般的股票,-1 的则为下跌的股票。希望根据这些已知的数据, 建立股票的评价模型,这样就可以利用模型评价新的股票。

    1.导入数据

    clear all, close all
    
    s = dataset('xlsfile', 'SampleA1.xlsx');

    2.多元线性回归

            当导入数据后,就可以先建立一个多元线性回归模型,具体实现过程和结果如下:

    myFit = LinearModel.fit(s);
    
    disp(myFit)
    sx=s(:,1:10);
    sy=s(:,11);
    n=1:size(s,1);
    sy1= predict(myFit,sx);
    figure
    plot(n,sy, 'ob', n, sy1,'*r')
    xlabel('样本编号', 'fontsize',12)
    ylabel('综合得分', 'fontsize',12)
    title('多元线性回归模型', 'fontsize',12)
    set(gca, 'linewidth',2)

            该段程序执行后,得到的模型及模型中的参数如下。

            利用该模型对原始数据进行预测,得到的股票综合得分如图1所示。从图中可以看出,尽管这些数据存在一定的偏差,但三个簇的分层非常明显,说明模型在刻画历史数据方面具有较高的准确度。

                     图1  多元线性回归模型得到的综合得分与原始得分的比较图

    3.逐步回归

            上述是对所有变量进行回归,也可以使用逐步回归进行因子筛选,并可以得到优选因子后的模型,具体实现过程如下:

    myFit2 = LinearModel.stepwise(s);
    
    disp(myFit2)
    sy2= predict(myFit2,sx);
    figure
    plot(n,sy, 'ob', n, sy2,'*r')
    xlabel('样本编号', 'fontsize',12)
    ylabel('综合得分', 'fontsize',12)
    title('逐步回归模型', 'fontsize',12)
    set(gca, 'linewidth',2)

            该段程序执行后,得到的模型及模型中的参数如下。

            从该模型中可以看出,逐步回归模型得到的模型少了 5 个单一因子,多了 5 个组合因子,模型的决定系数反而提高了一些,这说明逐步回归得到的模型精度更高些,影响因子更少些,这对于分析模型本身是非常有帮助的,尤其是在剔除因子方面。

            利用该模型对原始数据进行预测,得到的股票综合得分如图 2 所示,总体趋势和图 1 相似。

                     图2  逐步回归模型得到的综合得分与原始得分的比较图

            以上是线性加权法构建评价型模型的方法, 所用的程序框架对绝大多数的这类问题都可以直接应用,核心是要构建评价的指标体系, 这是建模的基本功。总的来说,线性加权法的特点是:

    (1)该方法能使得各评价指标间作用得到线性补偿,保证综合评价指标的公平性;

    (2)该方法中权重系数的对评价结果的影响明显,即权重较大指标值对综合指标作用较大;

    (3)该方法计算简便,可操作性强,便于推广使用。

    2.层次分析法

            层次分析法 (Analytic Hierarchy Process, AHP) 是美国运筹学家萨蒂(T. L. Saaty)等人 20 世纪 70 年代初提出的一种决策方法,它是将半定性、半定量问题转化为定量问题的有效途径,它将各种因素层次化,并逐层比较多种关联因素,为分析和预测事物的发展提供可比较的定量依据,它特别适用于那些难于完全用定量进行分析的复杂问题。因此在资源分配、选优排序、政策分析、冲突求解以及决策预报等领域得到广泛的应用。

            AHP 的本质是根据人们对事物的认知特征,将感性认识进行定量化的过程。人们在分析多个因素时,大脑很难同时梳理那么多的信息,而层次分析法的优势就是通过对因素归纳、分层,并逐层分析和量化事物,以达到对复杂事物的更准确认识,从而帮助决策。

            在数学建模中,层次分析法的应用场景比较多,归纳起来,主要有以下几个场景:

    (1) 评价、评判类的题目。这类题目都可以直接用层次分析法来评价,例如奥运会的评价、彩票方案的评价、导师和学生的相互选择、建模论文的评价、城市空气质量分析等。

    (2) 资源分配和决策类的题目。这类题目可以转化为评价类的题目,然后按照 AHP 进行求解,例如将一笔资金进行投资,有几个备选项目,那么如何进行投资分配最合理呢?这类题目中还有一个典型的应用,就是方案的选择问题,比如旅游景点的选择、电脑的挑选、学校的选择、专业的选择等等,这类应用可以说是 AHP 法最经典的应用场景了。

    (3) 一些优化问题,尤其是多目标优化问题。对于通常的优化问题,目前已有成熟的方法求解。然而,这些优化问题一旦具有如下特性之一,如:

    ①问题中存在一些难以度量的因素;

    ②问题的结构在很大程度上依赖于决策者的经验;

    ③问题的某些变量之间存在相关性;

    ④需要加入决策者的经验、偏好等因素,

    这时就很难单纯依靠一个优化的数学模型来求解。这类问题,通常的做法是借助 AHP 法将复杂的问题转化为典型的、便于求解的优化问题,比如多目标规划,借助层次分析法,确定各个目标的权重,从而将多目标规划问题转化为可以求解的单目标规划问题。

            如何用 MATLAB 来实现层次分析法的过程,层次分析法中,需要 MATLAB 的地方主要就是将评判矩阵,转化为因素的权重矩阵。为此,这里只介绍如何用 MATLAB 来实现这一转化。

    将评判矩阵转化为权重矩阵,通常的做法就是求解矩阵最大特征根和对应阵向量。

    需要注意的是,在将评判矩阵转化为权重向量的过程中,一般需要先判断评判矩阵的一致性,因为通过一致性检验的矩阵,得到的权重才更可靠。

            下面就以一个实例来说明如何应用 MATLAB 来求解权重矩阵,具体程序如下:

    %% AHP法权重计算MATLAB程序
    
    %% 数据读入
    
    clc
    
    clear all
    
    A=[1 2 6; 1/2 1 4; 1/6 1/4 1];% 评判矩阵
    
    %% 一致性检验和权向量计算
    
    [n,n]=size(A);
    
    [v,d]=eig(A);
    
    r=d(1,1);
    
    CI=(r-n)/(n-1);
    
    RI=[0 0 0.58 0.90 1.12 1.24 1.32 1.41 1.45 1.49 1.52 1.54 1.56 1.58 1.59];
    
    CR=CI/RI(n);
    
    if  CR<0.10
    
        CR_Result='通过';
    
       else
    
        CR_Result='不通过';  
    
    end
    
     
    
    %% 权向量计算
    
    w=v(:,1)/sum(v(:,1));
    
    w=w';
    
     
    
    %% 结果输出
    
    disp('该判断矩阵权向量计算报告:');
    
    disp(['一致性指标:' num2str(CI)]);
    
    disp(['一致性比例:' num2str(CR)]);
    
    disp(['一致性检验结果:' CR_Result]);
    
    disp(['特征值:' num2str(r)]);
    
    disp(['权向量:' num2str(w)]);

            运行该程序,可得到以下结果:

    该判断矩阵权向量计算报告:
    
    一致性指标:0.0046014
    
    一致性比例:0.0079334
    
    一致性检验结果:通过
    
    特征值:3.0092
    
    权向量:0.58763     0.32339    0.088983

            应用这段程序时,只要将评判矩阵输入到程序中,其它地方都不需要修改,然后就可以直接、准确地计算出对应的结果,所以这段程序在实际使用中非常灵活。

    展开全文
  • 层次分析法计算权重

    千次阅读 2020-11-26 11:13:02
    初学者搞的层次分析法,先放代码再放图 import numpy as np import pandas as pd import pymysql import math import time import datetime from sqlalchemy import create_engine class AHP: """ 相关信息的传入...

    初学者搞的层次分析法,先放代码再放图

    import numpy as np
    import pandas as pd
    import pymysql
    import math
    import time
    import datetime
    from sqlalchemy import create_engine
    
    class AHP:
        """
        相关信息的传入和准备
        """
    
        def __init__(self, array):
            ## 记录矩阵相关信息
            self.array = array
            ## 记录矩阵大小
            self.n = array.shape[0]
            # 初始化RI值,用于一致性检验
            self.RI_list = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]
            # 矩阵的特征值和特征向量
            self.eig_val, self.eig_vector = np.linalg.eig(self.array)
            # 矩阵的最大特征值
            self.max_eig_val = np.max(self.eig_val)
            # 矩阵最大特征值对应的特征向量
            self.max_eig_vector = self.eig_vector[:, np.argmax(self.eig_val)].real
            # 矩阵的一致性指标CI
            self.CI_val = (self.max_eig_val - self.n) / (self.n - 1)
            # 矩阵的一致性比例CR
            self.CR_val = self.CI_val / (self.RI_list[self.n - 1])
    
        """
        一致性判断
        """
        def test_consist(self):
            # 打印矩阵的一致性指标CI和一致性比例CR
            print("判断矩阵的CI值为:" + str(self.CI_val))
            print("判断矩阵的CR值为:" + str(self.CR_val))
            # 进行一致性检验判断
            if self.n == 2:  # 当只有两个子因素的情况
                print("仅包含两个子因素,不存在一致性问题")
            else:
                if self.CR_val < 0.1:  # CR值小于0.1,可以通过一致性检验
                    print("判断矩阵的CR值为" + str(self.CR_val) + ",通过一致性检验")
                    return True
                else:  # CR值大于0.1, 一致性检验不通过
                    print("判断矩阵的CR值为" + str(self.CR_val) + "未通过一致性检验")
                    return False
        """
        特征值法求权重
        """
        def cal_weight__by_eigenvalue_method(self):
            # 将矩阵最大特征值对应的特征向量进行归一化处理就得到了权重
            array_weight = self.max_eig_vector / np.sum(self.max_eig_vector)
            # 打印权重向量
            for index in range(len(array_weight)):
                array_weight[index] = round(array_weight[index],2)
            print(array_weight)
            # 返回权重向量的23
            # 值
            return array_weight
    
    
    
    '''
      计算权重
    '''
    RI = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]
    
    #信息准确
    mes = np.array([[1,3,5],
                    [1/3,1,3],
                    [1/5, 1/3, 1]])
    m1 = len(mes)  # 获取指标个数
    n1 = len(mes[0])
    R1 = np.linalg.matrix_rank(mes)  # 求判断矩阵的秩
    V1, D1 = np.linalg.eig(mes)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list1 = list(V1)
    B1 = np.max(list1)  # 最大特征值
    index1 = list1.index(B1)
    C1 = D1[:, index1]  # 对应特征向量
    CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
    CI1 = CI1.real
    CR1 = CI1 / RI[n1]
    CR1 = CR1.real
    if CR1 < 0.10:
        print("信息准确权重:")
        # 特征值法求权重
        mes_weight = AHP(mes).cal_weight__by_eigenvalue_method()
    
    
    #交费行为
    pay = np.array([[1, 1.1, 1.3, 5.3, 5.7, 7],
                    [1 / 1.1, 1, 1.2, 5.2, 5.5, 6.8],
                    [1 / 1.3, 1 / 1.2, 1, 5, 5.4, 6.6],
                    [1 / 5.3, 1 / 5.2, 1 / 5, 1, 1.5, 2.8],
                    [1 / 5.7, 1 / 5.5, 1 / 5.4, 1 / 1.5, 1, 2.5],
                    [1 / 7, 1 / 6.8, 1 / 6.6, 1 / 2.8, 1 / 2.5, 1]])
    m2 = len(pay)  # 获取指标个数
    n2 = len(pay[0])
    R2 = np.linalg.matrix_rank(pay)  # 求判断矩阵的秩
    V2, D2 = np.linalg.eig(pay)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list2 = list(V2)
    B2 = np.max(list2)  # 最大特征值
    index2 = list2.index(B2)
    C2 = D2[:, index2]  # 对应特征向量
    CI2 = (B2 - n2) / (n2 - 1)  # 计算一致性检验指标CI
    CI2 = CI2.real
    CR2 = CI2 / RI[n2]
    CR2 = CR2.real
    if CR2 < 0.10:
        print("交费行为权重:")
        # 特征值法求权重
        pay_weight = AHP(pay).cal_weight__by_eigenvalue_method()
    
    #用电行为
    elec = np.array([[1,2,3.5,3.8,5.5,5.9],
                     [1/2,1,3.3,3.5,5.4,5.7],
                     [1/3.5,1/3.3,1,1.5,3.5,3.7],
                     [1/3.8,1/3.5,1/1.5,1,3.2,3.5],
                     [1/5.5,1/5.4,1/3.5,1/3.2,1,1.3],
                     [1/5.9,1/5.7,1/3.7,1/3.5,1/1.3,1]
                     ])
    m3 = len(elec)  # 获取指标个数
    n3 = len(elec[0])
    R3 = np.linalg.matrix_rank(elec)  # 求判断矩阵的秩
    V3, D3 = np.linalg.eig(elec)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list3 = list(V3)
    B3 = np.max(list3)  # 最大特征值
    index3 = list3.index(B3)
    C3 = D3[:, index3]  # 对应特征向量
    CI3 = (B3 - n3) / (n3 - 1)  # 计算一致性检验指标CI
    CI3 = CI3.real
    CR3 = CI3 / RI[n3]
    CR3 = CR3.real
    if CR3 < 0.10:
        print("用电行为权重:")
        # 特征值法求权重
        elec_weight = AHP(elec).cal_weight__by_eigenvalue_method()
    
    #准则层判断矩阵
    credit = np.array([[1,3,5],
                    [1/3,1,3],
                    [1/5, 1/3, 1]])
    m1 = len(credit)  # 获取指标个数
    n1 = len(credit[0])
    R1 = np.linalg.matrix_rank(credit)  # 求判断矩阵的秩
    V1, D1 = np.linalg.eig(credit)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list1 = list(V1)
    B1 = np.max(list1)  # 最大特征值
    index1 = list1.index(B1)
    C1 = D1[:, index1]  # 对应特征向量
    CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
    CI1 = CI1.real
    CR1 = CI1 / RI[n1]
    CR1 = CR1.real
    if CR1 < 0.10:
        print("客户信用权重:")
        # 特征值法求权重
        weight = AHP(credit).cal_weight__by_eigenvalue_method()
    
    '''
    连接ads宽表,取出数据,计算信息质量得分、交费行为得分、用电行为得分、总得分
    '''
    
    # python读数据库
    # 连接mysql数据库
    conn = pymysql.connect(
        host='25.212.157.216',
        port=13306,
        user='jingyanyuan',
        password='Jingyanyuan@%458',
        db='jingyanyuan',
        charset='utf8',
        cursorclass=pymysql.cursors.DictCursor)#json格式
    # 创建游标
    cursor = conn.cursor()  # 执行完毕返回的结果默认以元组的形式保存
    # 使用 execute()  方法执行 SQL 查询
    sql = 'select * from mrt_cons_credit_jyy_m'
    cursor.execute(sql)
    data = cursor.fetchall()
    update_sql = 'update mrt_cons_credit_jyy_m set info_ql_sco =(%s),deal_ql_sco =(%s) , elec_mn_sco =(%s), credit_sco =(%s)  where cons_no = (%s)'
    update_data = []
    #循环遍历所有数据
    for index in range(len(data)):
        total_score = 0
        row_data = data[index]
        #基础信息
        cons_no = data['cons_no']
        cons_nm = data['cons_nm']
        cert_typ = data['cert_typ']
        cert_no = data['cert_no']
        elec_typ = data['elec_typ']
        elec_addr = data['elec_addr']
        tel_no = data['tel_no']
        owner_dt = data['owner_dt']
        ls_wechat = data['ls_wechat']
        ls_app = data['is_app']
        mes_len = 18
        '''
            信息准确得分    
        '''
        mes_score = 0
    
        # 基础信息完整性
        count_null = 0
        if (cons_no.strip() == ''):
            count_null += 1
        if (cons_nm.strip() == ''):
            count_null += 1
        if (cert_typ.strip() == ''):
            count_null += 1
        if (cert_no.strip() == ''):
            count_null += 1
        if (elec_typ.strip() == ''):
            count_null += 1
        if (elec_addr.strip() == ''):
            count_null += 1
        if (tel_no.strip() == ''):
            count_null += 1
        if (owner_dt.strip() == ''):
            count_null += 1
        if (count_null == 0):
            mes_score += mes_weight[0] * 100
        elif (count_null == 1):
            mes_score += mes_weight[0] * 75
        elif (count_null == 2):
            mes_score += mes_weight[0] * 50
        elif (count_null >=3 and count_null<mes_len):
            mes_score += mes_weight[0] * 25
        else:
            mes_score += 0
    
        #基础信息准确性
        if(cert_typ==1 and len(cert_no)!=18):
            mes_score += mes_weight[1] * 0
        else:
            mes_score += mes_weight[1] * 100
    
        #附加信息完整性
        if(ls_app==0 and ls_wechat==0):
            mes_score += mes_weight[2] * 0
        elif (ls_app == 1 and  ls_wechat == 1):
            mes_score += mes_weight[2] * 100
        else:
            mes_score += mes_weight[2] * 50
        print("信息准确得分:\n")
        print(mes_score)
    
        '''
            交费行为得分    
        '''
        pay_score = 0
        rcvbl_penalty_sum = data['rcvbl_penalty_sum']
        deal_amt_sum = data['deal_amt_sum']
        deal_channel_Pref = data['deal_channel_Pref']
        deal_channel_kind = data['deal_channel_kind']
    
        # 交费金额
        if (deal_amt_sum >=0 and deal_amt_sum < 87.6):
            pay_score += 0
        elif (deal_amt_sum>= 87.6 and deal_amt_sum < 215):
            pay_score += pay_weight[0] * 25
        elif (deal_amt_sum>=215 and deal_amt_sum < 488):
            pay_score += pay_weight[0] * 50
        elif (deal_amt_sum>=488 and deal_amt_sum < 1360):
            pay_score += pay_weight[0] * 75
        else:
            pay_score += pay_weight[0] * 100
    
        # 累计违约金额占比
        pay_percent = round(rcvbl_penalty_sum/deal_amt_sum,4)
        if(pay_percent == 0):
            pay_score += pay_weight[1] * 100
        elif(pay_score<0.0003):
            pay_score += pay_weight[1] * 75
        elif (pay_score <0.0009):
            pay_score += pay_weight[1] * 50
        elif (pay_score < 0.0023):
            pay_score += pay_weight[1] * 25
        else:
            pay_score += 0
    
        # 累计违约金额
        if (rcvbl_penalty_sum == 0):
            pay_score += pay_weight[2] * 100
        elif (rcvbl_penalty_sum < 1.09):
            pay_score += pay_weight[2] * 75
        elif (rcvbl_penalty_sum < 3.95):
            pay_score += pay_weight[2] * 50
        elif (rcvbl_penalty_sum < 13.6):
            pay_score += pay_weight[2] * 25
        else:
            pay_score += 0
    
        # 交费渠道偏好
        if(deal_channel_Pref == '0203'):
            pay_score += pay_weight[3] * 75
        elif (deal_channel_Pref == '0307' or deal_channel_Pref == '030702'
              or deal_channel_Pref == '0306' or deal_channel_Pref == '011101'):
            pay_score += pay_weight[3] * 100
        else:
            pay_score += pay_weight[3] * 50
    
        # 交费渠道种类
        if(deal_channel_kind >= 3):
            pay_score += pay_weight[4] * 25
        elif (deal_channel_kind  == 2):
            pay_score += pay_weight[4] * 50
        else:
            pay_score += pay_weight[4] * 100
    
        #户龄
        now_date = datetime.datetime.fromtimestamp(time.time())
        owner_dt = datetime.datetime.fromtimestamp(owner_dt)
        dd = (now_date - owner_dt).days / 30
        dd = math.ceil(dd)
        if (dd <70 ):
            pay_score += pay_weight[5] * 25
        elif (dd<133):
            pay_score += pay_weight[4] * 50
        elif (dd <175):
            pay_score += pay_weight[4] * 75
        else:
            pay_score += pay_weight[4] * 100
    
        print("交费行为得分:\n")
        print(pay_score)
    
        elec_score = 0
    
        '''
           用电行为得分    
        '''
        violate_kind = data['violate_kind']
        violate_num = data['violate_num']
        violate_elecqt = data['violate_elecqt']
        steal_kind = data['steal_kind']
        steal_num = data['steal_num']
        steal_elecqt = data['steal_elecqt']
    
        # 违法次数
        if (steal_num == 0):
            elec_score += elec_weight[0] * 100
        elif (steal_num == 1):
            elec_score += elec_weight[0] * 10
        elif (steal_num == 2):
            elec_score += elec_weight[0] * 10
        else:
            elec_score += 0
    
        # 违规次数
        if (violate_num == 0):
            elec_score += elec_weight[1] * 100
        elif (violate_num == 1):
            elec_score += elec_weight[1] * 10
        elif (violate_num == 2):
            elec_score += elec_weight[1] * 10
        else:
            elec_score += 0
    
        # 违法追补电量
        if (steal_elecqt == 0):
            elec_score += elec_weight[2] * 100
        elif (steal_elecqt>0):
            elec_score += 0
    
        # 违规追补电量
        if (violate_elecqt == 0):
            elec_score += elec_weight[3] * 100
        elif (violate_elecqt > 0):
            elec_score += 0
    
        # 违法窃电种类
        if (steal_kind == 0):
            elec_score += elec_weight[4] * 100
        elif (steal_kind == 1):
            elec_score += elec_weight[4] * 10
        elif (steal_kind == 2):
            elec_score += elec_weight[4] * 10
        else:
            elec_score += 0
    
        #违规种类
        if (violate_kind == 0):
            elec_score += elec_weight[4] * 100
        elif (violate_kind == 1):
            elec_score += elec_weight[4] * 10
        elif (violate_kind == 2):
            elec_score += elec_weight[4] * 10
        else:
            elec_score += 0
        print("用户行为得分:\n")
        print(elec_score)
    
        #计算总分
        total_score = weight[0] * mes_score + weight[1] * pay_score + weight[2] * elec_score
    
        #赋值分数
        tmp_update_data = [mes_score,pay_score,elec_score,total_score,cons_no]
        update_data.append(tmp_update_data)
    
    
    # 批量更新
    try:
        res = cursor.executemany(update_sql, update_data)
        print(res)
        conn.commit()
    except Exception as e:
        print(e)
        conn.rollback()
    finally:
        # 关闭数据库
        cursor.close()
        conn.close()
    
    
    

    在这里插入图片描述

    展开全文
  • 用人话讲明白AHP层次分析法(非常详细原理+简单工具实现)
  • AHP权重计算说明.pdf

    2019-11-07 15:59:16
    层次分析法AHP权重计算步骤详细说明,包括层次排序的一致性检验、层次总排序的一致性检验以及权重的计算
  • 数学建模之层次分析法的源程序,输入成对比较矩阵可以得到相应的权重值。层次分析法是数学建模的基础方法,也是比较简单易懂易于操作的。程序具有通用性。几乎只要是层次分析法,给出矩阵就可计算
  • 层次分析与一致性检验

    万次阅读 多人点赞 2020-12-20 17:19:25
    目录1、层次分析法的基本步骤1.1、建立层次结构模型1.2、构造判断(成对比较)矩阵1.3、层次排序及一致性检验1.4、 层次总排序及其一致性检验2、总结:层次分析法的4步3、实例:去哪儿旅游5、为什么层次分析法要进行...
  • 如何实现按照计算后的结果排序

    千次阅读 2018-10-23 21:49:48
    在做分组报表统计时,我们经常会被要求按照数据升序或降序排序。在 group 函数的参数中,我们可以指定分组后对组的排序表达式,这样报表展现时能够直接根据该表达式进行排序了。我们先来看一个简单的例子,如下图所...
  • 建模方法(九)-层次分析法(AHP)算法和应用

    万次阅读 多人点赞 2018-08-26 20:49:25
    问题提出 ...AHP可以解决给指标计算权值,可以帮助我们对可选方案做决策。 层次分析算法的思想 他依靠目标与影响目标的因素的联系紧密程度给各个指标或者候选方案赋予一个权值。 算法步骤 ...
  • 层次分析法(AHP)

    2022-06-23 09:06:46
    层次分析法
  • 该算法基于通信强度排序方法实现通信社区的有效检出,基于通信密度分布生成高分辨率层次嵌套树,通过距离矢量修剪嵌套树,实现社区稳定检测和层次结构分析同时降低计算复杂度。该算法使用真实网络数据进行了有效验证...
  • 层次分析法(AHP).py

    2019-05-16 11:34:42
    层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、约束)的若干层次,通过定性指标模糊量化方法算出层次排序(权数)和总排序,以作为目标(多指标...
  • 考虑到一般的区间排序判断方法计算量较大且易于出现错误等缺点,引入了"可能度区间判断矩阵"排序法改进可拓评价方法,更有利于层次排序和方案比选;评价结果显示该井田5#主采煤层顶板稳定性级别为稳定。结果表明:改进可...
  • 其次利用层次分析法确定各因素的权向量,采用线性函数法和二元对比排序法解出定量与定性指标的隶属度,并构建隶属矩阵,从而建立模糊综合评价模型;最后采用模糊评判法计算出每个方案的综合优越度及选出最优方案.以张家...
  • 数学建模数学建模评价类方法02——层次分析法前言一、基本介绍1.1 简单介绍1.2 详细介绍1.3 优劣势1.3.1 优势1.3.2 劣势二、基本步骤2.1 建立层次结构模型2.2 构造判断矩阵2.3 层次排序及其一致性检验2.4 层次总...
  • AHP层次分析法具体操作

    千次阅读 2022-01-14 23:37:28
    总排序方法 (1)先算出第二层和第三层,也就是图中标准层和方案层的比较矩阵 (2)对成对比较矩阵​​​​​​​可以求层次总排序的权向量并进行一致性检验,结果如下: 计算 ​​​​​​​可知 ​​​​​​​...
  • 层次分析法(AHP)

    千次阅读 2021-11-12 11:50:18
    简介: AHP是AnalyticHierarchyProcess的简称,中文名为:层次分析法,是美国运筹学家、匹兹堡大学T. L. Saaty教授在20世纪70年代初期提出的。...而后,利用数学方法计算反映每一层次元素的相对重要性次序..
  • 201层次分析法1

    2022-08-08 17:48:09
    (1)基本原理层次分析法通过定性指标模糊量化方法,计算层次排序重要性权数和总排序,来确定多目标多方案优化决策中各指标的权重 (2)操作步骤① 建立层次分析模
  • 重点从文档 集中发现话题,在计算文档话题层次排序得分等方面给出了详细的模型定义、求解过程和理论依据。提出了一个通 用的异构网络排序模型,该模型一方面为源域和目标域之间的关联进行建模,同时在2个域中学习排序...
  • 层次分析法(AHP)详细步骤

    万次阅读 多人点赞 2019-01-07 13:01:10
    层次总排序及其一致性检验 计算某一层次所有因素对于最高层(目标)相对重要性的权值,称为层次总排序。 这一过程是从最高层次到最低层次依次进行的。 A层 mmm个因素 A1,A2,⋅⋅⋅,Am,A_{1},A_{2},···,A_{m},A1...
  • 层次分析法AHP_1.m

    2019-05-16 11:36:23
    层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、约束)的若干层次,通过定性指标模糊量化方法算出层次排序(权数)和总排序,以作为目标(多指标...
  • 在互补判断矩阵排序理论的基础上,结合最优化方法,将互补判断矩阵特征向量法引入层次分析中,提出了一种基于互补判断矩阵特征向量法的层次分析方法。通过对几种常见MDO算法的设计变量、约束、计算精度和计算复杂度...
  • 本文运用层次分析法对影响高校仪器设备招标评标评标的各种指标分层排序,组成一个有序的递阶层次结构,通过计算确定其权重,将定性和定量相结合提供一种科学的方法,从而减少人为因素的影响,体现"公开、公平、公正"的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,977
精华内容 39,990
关键字:

层次总排序的计算方法