评价类问题解决方法
 
层次分析法
Topic
解决评价类问题，需要想到一下三个问题：
 
评价目标是什么
为达到这个目标有哪几种可选方案
评价准则或指标是什么
引例
 

高考结束，选择旅游地：
 
评价目标——选择最佳旅游景点
可选方案——苏杭、北戴河、桂林
指标——景色、花费、居住、饮食、交通
 
指标权重
苏杭
北戴河
桂林
景色
-----
----
----
-----
花费
-----
----
-----
----
居住
-----
-----
-----
-----
饮食
-----
-----
-----
-----
交通
-----
-----
-----
-----
 
 
 
 
 
 
 
 
 
 
 
 
ps:这里的颜色可能不太明显。（同种颜色的相加和为1） 
 
分而治之的思想来解决
 

 解决方法：两个两个指标进行比较，最终根据两两比较的结果来推算权重。
 

  1-9重要程度参考表
 
标度
含义
1
表示两个因素相比，具有同样重要性
3
表示两个因素相比，一个因素比另一个因素稍微重要
5
表示两个因素相比，一个因素比里一个因素明显重要
7
表示两个因素相比，一个因素比另一个因素强烈重要
9
表示两个因素相比，一个因素比另一个因素极端重要
2，4，6，8
上述两相邻判断的中值
倒数
意会吧，孩子
 
 
 
 
 
 
 
 
 
 
 
 
表格填写（查论文 or 专家言谈）
 

  相互比较后数据填写表
 
 
景色
花费
居住
饮食
交通
景色
1
1/2
4
3
3
花费
2
1
7
5
5
居住
1/4
1/7
1
1/2
1/3
饮食
1/3
1/5
2
1
1
交通
1/3
1/5
3
1
1
 
 
 
 
 
 
 
 
 
 
概念区别（判断矩阵 and 正互反矩阵）
 

 
所以，上图矩阵为 判断矩阵。
 
得到判断矩阵后，就可以计算权重。
 

  方案表1
 
花费
苏杭
北戴河
桂林
苏杭
1
1/3
1/8
北戴河
3
1
1/3
桂林
8
3
1
 
 
 
 
 
 

  方案表2
 
居住
苏杭
北戴河
桂林
苏杭
1
1
3
北戴河
1
1
3
桂林
1/3
1/3
1
 
 
 
 
 
 

  方案表3
 
饮食
苏杭
北戴河
桂林
苏杭
1
3
4
北戴河
1/3
1
1
桂林
1/4
1
1
 
 
 
 
 
 

  方案表4
 
交通
苏杭
北戴河
桂林
苏杭
1
1
1/4
北戴河
1
1
1/4
桂林
4
4
1
 
 
 
 
 
 

  方案表5
 
景色
苏杭
北戴河
桂林
苏杭
1
2
1
北戴河
1/2
1
2
桂林
1/5
1/2
1
 
 
 
 
 
 
 
 
NOTICE：
 
DEF：苏杭 = A  北戴河 = B 桂林 = C
 
A景色 > B景色
 
A景色 = C景色
 
BUT： C景色 > B 景色
 
出现里矛盾—— 不一致现象 
 
一致矩阵的例子
 

 
各行个列之间成倍数关系
 
 
在使用判断矩阵求权重之前，必须对齐进行一致性检验。
 
一致性检验
 

原理：检验我们构造的判断矩阵和一致矩阵是否有太大差别
 
步骤：
 
计算 一致性指标CI                
查找对应的平均随机一致性指标RI
n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
 
 
 
 
3.计算一致性比例CR
 
 
如果 CR < 0.1 ，则可认为判断矩阵的一致性可以接受；否则需要对判断矩阵进行修正
 
一致矩阵怎么计算权重
 

 
因为成比例，所以计算一列即可
苏杭 =  1 /（1+0.5+0.25） 
北戴河 = 0.5 /（1+0.5+0.25） 
桂林 = 0.25 /（1+0.5+0.25）
判断矩阵计算权重
 

景色
苏杭
北戴河
桂林
苏杭
1
2
5
北戴河
1/2
1
2
桂林
1/5
1/2
1
 
 
 
 
 
 
仅使用第一列的数据，计算出来的权重： 
苏杭 =  1 /（1+0.5+0.2）= 0.5882  
北戴河 = 0.5 /（1+0.5+0.2）= 0.2941 
桂林 = 0.2 /（1+0.5+0.2）= 0.1177 
使用第二列的数据，计算出来的权重： 
苏杭 =  2 /（2+1+0.5）= 0.5714 
北戴河 = 1 /（2+1+0.5）= 0.2857 
桂林 = 0.5 /（2+1+0.5）=  0.1429 
使用第三列的数据，计算出来的权重： 
苏杭 =  5 /（5+2+1）= 0.625 
北戴河 = 2 /（5+2+1）= 0.25 
桂林 = 1 /（5+2+1）= 0.125
方法1：算数平均法求权重
 
苏杭 = (0.5882+0.5714+0.625)/3=0.5949 
北戴河 = (0.2941+0.2857+0.25)/3=0.2766 
桂林 = (0.1177+0.1429+0.125)/3=0.1285
方法2：几何平均法求权重
 
方法3：特征值法求权重
 
何为层次分析法：
 


         层次分析法（
 The Analytic Hierarchy Process
 即 
 AHP)
 是由美国运筹学家、 匹兹堡大学教授T . L. Saaty
 于
 20
 世纪
 70
 年代创立的一种系统分析与决策的综合 评价方法，是在充分研究了人类思维过程的基础上提出来的，它较合理地解 决了定性问题定量化的处理过程。 
 

         AHP
 的主要特点是通过建立递阶层次结构，把人类的判断转化到若干因 素两两之间重要度的比较上，从而把难于量化的定性判断转化为可操作的重 要度的比较上面。在许多情况下，决策者可以直接使用AHP
 进行决策，极大 地提高了决策的有效性、可靠性和可行性，但其本质是一种思维方式，它把 复杂问题分解成多个组成因素，又将这些因素按支配关系分别形成递阶层次 
 

 结构，通过两两比较的方法确定决策方案相对重要度的总排序。整个过程体 现了人类决策思维的基本特征，即分解、判断、综合，克服了其他方法回避决策者主观判断的缺点。
 
论文中书写步骤：
 

 
第二步：
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
模型拓展
 

、
 
 
 

 
聊聊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实现

 
 
目录：
 
 
层次分析法简介
层次分析法基本原理
构造判断矩阵
一致性检验
一致性检验通过的判断矩阵求权重
 4.1 算数平均法求权重
 4.2 几何平均法求权重
 4.3 特征值法求权重
总结
 
 
0. 层次分析法简介
 层次分析法（Analytic Hierarchy Process，简称AHP）主要是对于定性的决策问题进行定量化分析的方法。举个例子，在日常生活中，我们经常需要进行感性的判断，比如报高考志愿，感觉清华北大都很好，到底要报哪个；再比如去市场买菜，到底是买青椒做青椒炒鸡蛋，还是买黄瓜做黄瓜炒鸡蛋；再比如想去出游，到底是去公园A还是公园B。上面提到的这些问题，都是决策，也叫做评价类问题，最终的目的就是要评价到底哪个更好。这个方法在数学建模比赛，比如美赛等比赛中有时会用到，另外对日常的生活也有一定的指导。
 
那么如何用数学的评价体系去解决这类看似非常感性的问题呢，这就诞生了我们今天要讲的层次分析法。这里我们从浅入深对于层次分析法进行一个讲解。
 
1. 层次分析法基本原理
 
这里我们举一个例子让大家大致的了解层次分析法的基本原理。假如，小明想买一瓶饮料喝，他在纠结到底是买可乐好，还是雪碧好，还是汇源果汁，他非常的纠结，于是想建个模型来分析到底买哪种饮料好。
 
为了实现这个评价，首先我们要确定评价的指标，比如这里我们设定三种指标：饮料的口味，饮料的价格和饮料健康程度，那么最直观的量化方法就是给各个因素一个权重，然后给各个饮料进行打分，如下表：
 
 
表格中相同颜色的区域加和需要为1，这是为了标准化。所以我们来看一下这个表格，在评价指标方面，小明很注重健康因为给了健康0.5的权重，其次是口味0.3，最后是价格0.2； 具体的在口味方面，小明觉得可乐和雪碧差不多（0.35），果汁稍微差一点是0.3 以此类推，小明就只做了这张表格，为了计算每种饮料的得分，我们只需要把备选方案的权重乘对应的评价指标的权重并且加和即可，也就是：
 
可乐的最终得分是0.35×0.3+0.4×0.2+0.1×0.5 = 0.1005；
 雪碧的最终得分是 0.35×0.3+0.4×0.2+0.2×0.5 = 0.1505；
 汇源果汁的最终得分是 0.3×0.3+0.2×0.2+0.7×0.5 = 0.379；
 
通过比大小我们就看得出来汇源果汁的最终得分最高，所以小明应该选择汇源果汁。
 
回顾一下，为了量化的评价，我们需要确定评价指标，和备选方案两个重要的因素，接着分配权重（记得加和为1），最终通过乘法然后加和的方式得到最终的量化得分，从而做出最终的评价。
 
2. 构造判断矩阵
 
层级分析法就是简单的编造几个权重然后进行抉择么？当然不是，如何客观合理的设定表格中的权重才是重中之重，因此，我们这里介绍如何构造判断矩阵。
 
在现实问题中，往往存在很多个评价指标，让小明从饮料的口味，价格，健康，瓶盖能不能兑奖，瓶子是不是好看，自己是不是汇源果汁的代言人……等很多评价指标中给出合理的权重是一个非常困难的事情，也许小明现在给出的权重和一会儿给出的权重就完全不同，所以，为了简化思维过程，我们首先进行评价指标的两两比较，再将比较结果汇总成最终的权重。
 
为了量化两两比较的结果，我们要祭出一个评价体系表格（不要问我从哪里来~它的故乡在远方）说白了，就是在A和B两者比较中划分了一个1到9的重要等级。
 
 
举个例子，假如说饮料的健康性（A）和口味（B）相比，健康要明显重要，则我们就可以说A比B的权重是5。之后我们开始构建我们的判断矩阵。
 
 
上述的表格就是一个判断矩阵，我们可以看到这个判断矩阵有几个特点，对角线都为1，而且对角线对称的元素相乘都为1，这样的矩阵也被称为正互反矩阵。
 为了更加数学的描述，我们设定矩阵的元素定义为a_ij代表了与j相比i的重要性，其中i表示行，j表示列， 其中a_ij>0而且a_ij×a_ji=1即对称元素相乘为1。当i=j时，也就是元素在对角线上时，元素为1。另外理想的情况下要满足a_ij=a_ik×a_kj 这个理想的条件我们在以后说明
 
在构造判断矩阵的过程中我们的元素是两两进行判断的，所以是不是有可能出现问题呢？答案是有可能的，我们将表格中的元素进行一个更改，并用绿色标记出，随后得到了如下的表格
 
 
我们看第一行，口味比价格重要（口味>价格）同时健康比口味重要（健康>口味），那么按照正常的推理我们是不是应该得到健康比价格重要（健康>口味>价格）然而实际上表格中填写的是价格比健康重要（价格>健康）这就出现了矛盾，也就是不一致现象。在理想情况下，
 ，所以说，在理想的情况下a_ij=a_ik×a_kj 。理想的情况下的判断矩阵也有一些很好的性质，比如行列成比例，也就是说矩阵的秩为1，这里不进行深入的讨论。但是大部分的情况下，没办法达到如此的完美，那么为了量化评价这种不一致现象的大小，就需要在运算权重之前进行一致性的检验。
 
回顾一下，为了更合理的得到层次分析法表格中的权重，我们引入了数值为1-9的标度体系，并且用两两比较的方法构建了一个判断矩阵用于之后的权重计算，然而判断矩阵存在不一致的问题，因此我们要从数值的角度评价不一致的大小，以此引出一致性的检验。
 
3. 一致性检验
 
为了构建一个一致性的指标来验证矩阵的一致性，学者们主要参考了线性代数中的两个定理：
 
 
 
定理1：若A为一致性矩阵，则A的最大特征值λ_max⁡ = n，其中n为矩阵A的阶，A的其余特征值均为0。
 
 
定理2：n阶正互反矩阵为一致性矩阵，当且仅当其最大特征值λ_max⁡ = n，并且当正互反矩阵非一致时，必有λ_max⁡ > n。
 
 
从定理2的后半句中，我们可以看到，当一个正互反矩阵为非一致的矩阵的时候必有最大的特征值大于矩阵的阶，所以就想到可以使用最大特征值和矩阵的阶的差值来定义不一致性。这种想法看似复杂，其实超级朴素，比如时间不能倒流，所以出生后经过的年数就定义为你的年龄（年数-0）。
 
为此就定义了一致性指标CI，CI = (λ_max – n) / (n -1)。也就是说一致性指标CI越大，整个矩阵就越不一致，当CI是0的时候是完全理想的一直矩阵。（难道这不应该叫不一致性指标么？？？）
 
另外，为了得到计算出来的一致性指标到底是大还是小，我们又构建了平均随机一致性指标RI，该指标的构建方法是随机构建1000个正互反矩阵，并计算一致性指标的平均值。这里的RI也就是说当矩阵的阶数为n的时候随机的平均一致性。这相当于一把尺子，告诉大家如果完全随机（瞎蒙）的填写这个判断矩阵的结果的话，那么你的一致性指标的期望就大概是这个RI的值。RI如何计算呢？查表就可以了。
 
 当CI和RI的比值小于0.1的时候，我们认为这个矩阵是一致的，也就是说你矩阵的一致性指标，要比平均的瞎蒙的一致性指标小一个数量级的时候，我们认为你就不是乱猜的了。这样我们就构建了我们的一致性比例CR = CI/ RI。如果说一个正互反矩阵的一致性比例没有小于0.1，那么就需要调整矩阵以满足要求。
 
 
举个例子，我们以这个判断矩阵为例，计算它是否满足一致性的要求，第一步是计算其最大的特征值，在matlab中，我们可以使用[x,y] = eig([1,3,1/5;1/3,1,1/6;5,6,1])； l_max = max(diag(y))； 计算得到，最后计算得到的最大特征值为3.0940， 我们可以看到这个值满足我们定理2中所说的要比矩阵的阶数3大。CI = (l_max -3) / ( 3 -1 ); 计算CI值是0.0470。RI值通过查表得到是0.52，最后我们的RI值就是CI/RI = 0.0904 < 0.1 所以这个矩阵满足一致性的要求。
 
回顾一下，这里主要讲如何验证矩阵的一致性，为了验证一致性构造了一致性比例CR，满足CR小于0.1的就认为该判断矩阵合理，不满足的就要对判断矩阵进行调整，得到合理的判断矩阵，得到合理的判断矩阵之后，就可以进行最初的，层次分析法的计算了。
 
4.一致性检验通过的判断矩阵求权重
 
得到了合理的判断矩阵我们这里就要计算每个影响因素所占的权重，这里主要有三种方法，算数平均法，几何平均法，和特征值法求权重
 4.1 算数平均法求权重：（列归一化，行平均值）
 对每列进行归一化处理，并且按照行求平均值就得到了我们最终的权重，这是最简单的计算方法，具体的方法如下：step1:列归一化，
 最左上角的元素归一化就是1/(1+1/3+5)=0.18;
 第一行第二个元素的计算方法就是3/(3+1+6)=0.30以此类推；
 
 
Step2:行平均值：
 口味：（0.18+0.30+0.17）/3 = 0.22;
 价格：（0.06+0.10+0.14）/3 = 0.10;
 健康：（0.88+0.60+0.83）/3 = 0.77;
 正常权重的加和是1，这里因为四舍五入的原因有一定的偏差。得到了权重之后，我们就可以写入最开始的表格了（还记得嘛？在算了这么多之后一定要牢记使命，别忘了最开始计算这些东西的目的是什么）
 
 
4.2 几何平均法求权重：（行相乘开n次方，列归一化）
 
这里的计算方法就是将行的元素都相乘，然后再开对应的n次方，并对得到的n个数字进行归一化即可。
 
4.3 特征值法求权重：（最大特征值的特征向量归一化）
 
特征值法其实是应用最多的一个方法，就是求最大特征值所对应的特征向量并进行归一化处理，matlab的计算方法如下：[x,y] = eig([1,3,1/5;1/3,1,1/6;5,6,1])； vec_max = x(:,1);得到的vec_max就是最大特征值对应的特征向量了。在本例中是0.26,0.12,0.96在对其进行归一化的处理，得到0.19，0.09，0.72 这样我们就用另一种方法求得了权重。
 
回顾一下这里介绍了三种不同的方法对判断矩阵的权重进行计算。除了这三个影响因素的判断矩阵以外，具体的表格中可乐，雪碧和汇源果汁的判断矩阵构造方法也是一样的。只需要列出以下的表格，检验一致性并最终计算即可。
 
 
5. 总结
 以上就是层次分析法的全部过程，有几个小的问题需要进一步的讲解，当判断矩阵不满足一致性的时候我们调整的方法就是重新梳理整个矩阵的各个元素，可以利用理想状态下，行和列的元素成比例的性质进行微调。另外，层次分析法考虑的因素不能过多，不论是候选的种类，还是评价的指标都不能太多。除此之外，层次分析法主要是在主观的评价体系中进行决策，或者满意度的评价，当在一个问题中，已经有很多已知的数据的时候，这种方法就显得不太好了。

 
文章目录
 
1.定义
2.移动平均法、指数平滑法和季节模型
1.移动平均法
2.二次移动平均法及趋势移动平均法
  
 


 

 
1.定义
 
时间序列是按时间顺序排列的、随时间变化且相互关联的数据序列。对时间序列进行观察研究，找寻它的发展规律，预测它将来的走势就是时间序列分析。
 
时间序列根据所研究的依据不同，可有不同的分类。
 
按所研究的对象的多少分，有一元时间序列和多元时间序列.
按时间的连续性可将时间序列分为离散时间序列和连续时间序列两种.
按序列的统计特性分，有平稳时间序列和非平稳时间序列.如果一个时间序列的概率分布与时间t无关，则称该序列为严格的（狭义的）平稳时间序列。如果序列的一、二阶矩存在，而且对任意时刻t满足： 
  
均值为常数；
协方差为时间间隔τ的函数
 
 
则该该序列为宽平稳时间序列，也叫广义平稳时间序列。
 
对于这方面的内容，详情可以多参考概率论的随机过程部分-有相似之处。
 
按时间序列的分布规律来分，有高斯型时间序列和非高斯型时间序列。
 
本章的主要内容是分析一元的时间序列分析。
 
2.移动平均法、指数平滑法和季节模型
 
1.移动平均法
 
移动平均法是常用的时间序列预测方法，由于其简单而具有很好的实用价值.
 
设观测序列为y1，···，yT，取移动平均的项数N<T.一次移动平均值计算公式为
 
$$M_t^{(1)}(N)=\frac{1}{N}(y_t+y_{t-1}+\cdot \cdot \cdot +y_{t-N+1})=\frac{1}{N}\sum _{i=0}^{N-1}{y}_{t-i}$$
 
则有：
 
$$M_t^{(1)}(N)=\frac{1}{N}(y_{t-1}+\cdot \cdot \cdot +y_{t-N})+\frac{1}{N}(y_t-y_{t-N)}=M_{t-1}^{(1)}(N)+\frac{1}{N}(y_t-y_{t-N})$$
 
t+1期的预测值为$$\widehat{y_{t+1}}=M_t^{(1)}(N)$$
 
其预测标准误差为：
 
$$S=\sqrt{\frac{{\sum }_{t=N+1}^T(\widehat{y_t}-y_t{)}^2}{T-N}}$$
 
$$如果将\widehat{y_{t+1}}作为t+1期的实际值，那么就可以用\widehat{y_{t+1}}=M_t^{(1)}(N)计算第t+2期预测值\widehat{y_{t+2}}.一般地，也可响应地求得以后各期的预测值。但由于越远时期的预测，误差越大，因此\ast \ast 一次移动平均法一般仅应用于一个时期后的预测值（即预测第t+1期)\ast \ast$$
 
栗子：
 
汽车配件某年1~12年月份的化油器销售量（单位：只）统计数据见下表中第2行，试用一次移动平均法预测下一年1月份的销售量.
 
化油器销售量及一次移动平均法预测值表：
 
月份
1
2
3
4
5
6
7
8
9
10
11
12
预测
yi
423
358
434
445
527
429
502
480
384
427
446
N=3
405
412
469
467
461
452
469
455
430
419
N=5
437
439
452
466
473
444
444
448
分别取N=3，N=5，按预测公式
 
$$\widehat{y_{t+1}}(3)=M_t^1(3)=\frac{y_t+y_{t-1}+y_{t-2}}{3},t=3,4,\cdot \cdot \cdot ,12$$
 
$$\widehat{y_{t+1}}(5)=M_t^1(3)=\frac{y_t+y_{t-1}+y_{t-2}+y_{t-3}+y_{t-4}}{3},t=5,6,\cdot \cdot \cdot ,12$$
 
计算3个月和5个月移动平均预测值，分别见上表第三行和第四行。N=3时，预测的标准误差为56.5752；N=5时，预测的标准误差为39.8159.
 
通过预测后，可以看到，实际数据波动较大，经移动平均后，随机波动明显减少，且N越大，波动也越小。同时，也可以看到，一次移动平均法的预测标准误差还是有些大，对于实际数据波动较大的序列，一般较少采用此法进行预测。
 
代码实现：
 
import numpy as np
y=np.array([423,358,434,445,527,429,426,502,480,384,427,446])
def MoveAverage(y,N):
    Mt=['*']*N
    for i in range(N+1,len(y)+2):
        M=y[i-(N+1):i-1].mean()
        Mt.append(M)
    return Mt
yt3=MoveAverage(y,3) 
s3=np.sqrt(((y[3:]-yt3[3:-1])**2).mean())
yt5=MoveAverage(y,5)
s5=np.sqrt(((y[5:]-yt5[5:-1])**2).mean())
print('N=3时,预测值：',yt3,'，预测的标准误差：',s3)
print('N=5时,预测值：',yt5,'，预测的标准误差：',s5)
 
简单移动平均使用的是等量加权策略，可以利用卷积，相应代码如下：
 
def sma(arr,n):

​	weights=np.ones(n)/n

​	return np.convolve(weights,arr)[n-1:-n+1]
 
import numpy as np
y=np.array([423,358,434,445,527,429,426,502,480,384,427,446])
n1=3; yt1=np.convolve(np.ones(n1)/n1,y)[n1-1:-n1+1] ##左开右闭 np.convolve(np.ones(n1)/n1,y,mode='valid')  同样适用-且更加具有普适性
s1=np.sqrt(((y[n1:]-yt1[:-1])**2).mean())
n2=5; yt2=np.convolve(np.ones(n2)/n2,y)[n2-1:-n2+1]
s2=np.sqrt(((y[n2:]-yt2[:-1])**2).mean())
print('N=3时,预测值：',yt1,'，预测的标准误差：',s1)
print('N=5时,预测值：',yt2,'，预测的标准误差：',s2)
 
np.convolve(a, v, mode='full'):
 Returns the discrete, linear convolution of two one-dimensional sequences.

    The convolution operator is often seen in signal processing, where it
    models the effect of a linear time-invariant system on a signal [1]_.  In
    probability theory, the sum of two independent random variables is
    distributed according to the convolution of their individual
    distributions.

    If `v` is longer than `a`, the arrays are swapped before computation.

    Parameters
    ----------
    a : (N,) array_like
        First one-dimensional input array.
    v : (M,) array_like
        Second one-dimensional input array.
    mode : {'full', 'valid', 'same'}, optional
        'full':
          By default, mode is 'full'.  This returns the convolution
          at each point of overlap, with an output shape of (N+M-1,). At
          the end-points of the convolution, the signals do not overlap
          completely, and boundary effects may be seen.

        'same':
          Mode 'same' returns output of length ``max(M, N)``.  Boundary
          effects are still visible.

        'valid':
          Mode 'valid' returns output of length
          ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
          for points where the signals overlap completely.  Values outside
          the signal boundary have no effect.

    Returns
    -------
    out : ndarray
        Discrete, linear convolution of `a` and `v`.

    See Also
    --------
    scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
                               Transform.
    scipy.linalg.toeplitz : Used to construct the convolution operator.
    polymul : Polynomial multiplication. Same output as convolve, but also
              accepts poly1d objects as input.

 By default, mode is 'full'.  This returns the convolution
          at each point of overlap, with an output shape of (N+M-1,). At
          the end-points of the convolution, the signals do not overlap
          completely, and boundary effects may be seen.
          默认情况下，模式为“完整”。 这将返回卷积
           在每个重叠点，总的输出形状为（N + M-1，）。 在
           卷积的端点，信号不重叠
           完全可以看到边界效应。
 使用栗子：
  Examples
    --------
    Note how the convolution operator flips the second array
    before "sliding" the two across one another:

    >>> np.convolve([1, 2, 3], [0, 1, 0.5])
    array([0. , 1. , 2.5, 4. , 1.5])

    Only return the middle values of the convolution.
    Contains boundary effects, where zeros are taken
    into account:

    >>> np.convolve([1,2,3],[0,1,0.5], 'same')
    array([1. ,  2.5,  4. ])

    The two arrays are of the same length, so there
    is only one position where they completely overlap:

    >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
    array([2.5])

    了解什么是卷积：
  References
    ----------
    .. [1] Wikipedia, "Convolution",
        https://en.wikipedia.org/wiki/Convolution
            
            卷积公式可以描述为在时刻t处函数f（τ）的加权平均值，其中权重由g（–τ）给出，仅移动量t即可。随着t的变化，加权函数会强调输入函数的不同部分。

 

 
 离散序列的卷积求法
 
卷积关键词：权重-时间-叠加性-离散还是连续
 
2.二次移动平均法及趋势移动平均法
 
当预测变量的基本趋势发生变化时，一次移动平均法不能迅速适应这种变化.
 
当时间序列的变化为线性趋势时，一次移动平均法的滞后偏差使预测值偏低，不能进行合理的趋势外推。
 
二次移动平均法-就是对一次移动平均数再进行二次移动平均，再以一次移动平均值和二次移动平均值为基础建立预测模型，计算预测值的方法。
 
二次移动平均值计算公式为：
 
$$M_t^{(2)}=\frac{1}{N}(M_t^{(1)}+\cdot \cdot \cdot +M_{t-N+1}^{(1)})=M_{t-1}^{(2)}+\frac{1}{N}(M_t^{(1)}-M_{t-N}^{(1)})$$
 
当预测目标的基本趋势是在某一水平上下波动时，可用一次移动平均方法建立预测模型。当预测目标的基本趋势与某一线性模型相吻合时，常用二次移动平均法.但序列同时存在线性趋势和周期波动时，可用趋势移动平均法建立预测模型:
 
$$\widehat{y_{T+m}}=a_T+b_T^m,m=1,2,\cdot \cdot \cdot ,$$
 
$$其中a_T=2M_T^{(1)}-M_T^{(2)},b_T=\frac{2}{N-1}(M_T^{(1)}-M_T^{(2)}).$$