Part II. S2. 基于直觉模糊混合几何算子的多属性决策方法

2.1 直觉模糊加权几何算子

定义2.1

  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，若$\mathrm{IFWG}$是一个映射：$F_n\to F$，使得：
$${\mathrm{IFWG}}_{\omega }\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)=({\tilde{A}}_1{)}^{{\omega }_1}\oplus ({\tilde{A}}_2{)}^{{\omega }_2}\oplus ...\oplus ({\tilde{A}}_n{)}^{{\omega }_n}\text{\hspace{1em}(2.1)}$$
  则称$\mathrm{IFWG}$为直觉模糊加权几何算子，其中$\mathbf{\omega }={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$为${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$的权重向量，${\omega }_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{\omega }_j=1$

  特别地，若$\mathbf{\omega }={\left(\frac{1}{n},\frac{1}{n},...,\frac{1}{n}\right)}^T$，则$\mathrm{IFWG}$算子退化为直觉模糊几何算子：
$$\mathrm{IFG}\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)={\left({\tilde{A}}_1\oplus {\tilde{A}}_2\oplus ...\oplus {\tilde{A}}_n\right)}^{\frac{1}{n}}\text{\hspace{1em}(2.2)}$$

定理2.1
  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，则有$\mathrm{IFWG}$算子运算得到的结果仍然是直觉模糊数，且

$$\underline{{\mathrm{IFWG}}_{\omega }\left({\tilde{A}}_1,{\tilde{A}}_2,...{\tilde{A}}_n\right)=⟨{\prod _{j=1}^n\left({\mu }_j\right)}^{{\omega }_j},1-\prod _{j=1}^n{\left(1-{\nu }_j\right)}^{{\omega }_j}⟩}\text{\hspace{1em}(2.3)}$$

其中，$\omega ={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$为${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$的权重向量，${\omega }_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{\omega }_j=1$

推理过程：
  已知：（1）${\alpha }_1\oplus {\alpha }_2=\left({\mu }_{{\alpha }_1}+{\mu }_{{\alpha }_2}-{\mu }_{{\alpha }_1}{\mu }_{{\alpha }_2},{\nu }_{{\alpha }_1}{\nu }_{{\alpha }_2}\right)$；（2）${\alpha }^{\lambda }=\left({{\mu }_{\alpha }}^{\lambda },1-{\left(1-{\nu }_{\alpha }\right)}^{\lambda }\right)$

  原式：${\mathrm{IFWG}}_{\omega }\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)=({\tilde{A}}_1{)}^{{\omega }_1}\oplus ({\tilde{A}}_2{)}^{{\omega }_2}\oplus ...\oplus ({\tilde{A}}_n{)}^{{\omega }_n}$

  S1.计算：${{\tilde{A}}_1}^{{\omega }_1},{{\tilde{A}}_2}^{{\omega }_2},...,{{\tilde{A}}_n}^{{\omega }_n}$
  R1.可得：$T_1={{\tilde{A}}_1}^{{\omega }_1}=\left({{\mu }_1}^{{\omega }_1},1-{\left(1-{\nu }_1\right)}^{{\omega }_1}\right)$，$T_2={{\tilde{A}}_2}^{{\omega }_2}=\left({{\mu }_2}^{{\omega }_2},1-{\left(1-{\nu }_2\right)}^{{\omega }_2}\right)$，…，$T_n={{\tilde{A}}_n}^{{\omega }_n}=\left({{\mu }_n}^{{\omega }_n},1-{\left(1-{\nu }_n\right)}^{{\omega }_n}\right)$
  S2.计算：$T_1\oplus T_2$
  R2.可得：
$$\begin{array}{rl}{T}_1\oplus T_2& =\left({{\mu }_1}^{{\omega }_1}{{\mu }_2}^{{\omega }_2},1-{\left(1-{\nu }_1\right)}^{{\omega }_1}+1-{\left(1-{\nu }_2\right)}^{{\omega }_2}-\left(1-{\left(1-{\nu }_1\right)}^{{\omega }_1}\right)\left(1-{\left(1-{\nu }_1\right)}^{{\omega }_1}\right)\right)\\ & =\left({{\mu }_1}^{{\omega }_1}{{\mu }_2}^{{\omega }_2},2-{\left(1-{\nu }_1\right)}^{{\omega }_1}-{\left(1-{\nu }_2\right)}^{{\omega }_2}-\left[1-{\left(1-{\nu }_2\right)}^{{\omega }_2}-{\left(1-{\nu }_1\right)}^{{\omega }_1}+{\left(1-{\nu }_1\right)}^{{\omega }_1}{\left(1-{\nu }_2\right)}^{{\omega }_2}\right]\right)\\ & =\left({{\mu }_1}^{{\omega }_1}{{\mu }_2}^{{\omega }_2},1-{\left(1-{\nu }_1\right)}^{{\omega }_1}{\left(1-{\nu }_2\right)}^{{\omega }_2}\right)\end{array}$$
    同理可以计算得到：$T_1\oplus T_2\oplus T_3=\left({{\mu }_1}^{{\omega }_1}{{\mu }_2}^{{\omega }_2}{{\mu }_3}^{{\omega }_3},1-{\left(1-{\nu }_1\right)}^{{\omega }_1}{\left(1-{\nu }_2\right)}^{{\omega }_2}{\left(1-{\nu }_3\right)}^{{\omega }_3}\right)$

    依次类推，可得到：$T_1\oplus T_2\oplus ...\oplus T_n=\left({{\mu }_1}^{{\omega }_1}{{\mu }_2}^{{\omega }_2}...{{\mu }_n}^{{\omega }_n},1-{\left(1-{\nu }_1\right)}^{{\omega }_1}{\left(1-{\nu }_2\right)}^{{\omega }_2}...{\left(1-{\nu }_n\right)}^{{\omega }_n}\right)$

    合并结果为：$T_1\oplus T_2\oplus ...\oplus T_n=⟨{\prod }_{j=1}^n{\left({\mu }_j\right)}^{{\omega }_j},1-{{\prod }_{j=1}^n\left(1-{\nu }_j\right)}^{{\omega }_j}⟩$

    即：${\mathrm{IFWG}}_{\omega }\left({\tilde{A}}_1,{\tilde{A}}_2,...{\tilde{A}}_n\right)=⟨{\prod }_{j=1}^n{\left({\mu }_j\right)}^{{\omega }_j},1-{{\prod }_{j=1}^n\left(1-{\nu }_j\right)}^{{\omega }_j}⟩$

  $示例2.1$

  设${\tilde{A}}_1=⟨0.2,0.5⟩$，${\tilde{A}}_2=⟨0.7,0.1⟩$，${\tilde{A}}_3=⟨0.5,0.2⟩$，${\tilde{A}}_4=⟨0.4,0.3⟩$，${\tilde{A}}_5=⟨0.6,0.2⟩$为五个直觉模糊数，$\omega ={\left(0.20,0.25,0.18,0.22,0.15\right)}^T$为该直觉模糊数组权重向量，则$\mathrm{IFWG}$结果是多少？

  代码如下：

import numpy as np

def calculate_IFWG(IF_matrix,weight):
    IFWG = [1,1]
    for i in range(IF_matrix.shape[1]):
        IFWG[0] *= np.power(IF_matrix[0][i],weight[i])
        IFWG[1] *= np.power(1-IF_matrix[1][i],weight[i])
    IFWG[1] = 1 - IFWG[1]
    return IFWG
IF_matrix = np.array([[0.2,0.7,0.5,0.4,0.6],[0.5,0.1,0.2,0.3,0.2]])
weight = np.array([0.20,0.25,0.18,0.22,0.15])

print("IF矩阵：\n",IF_matrix)
print("权重向量：\n",weight)
print('IFWG：\n',calculate_IFWG(IF_matrix,weight))

IF矩阵：
[[0.2 0.7 0.5 0.4 0.6]
[0.5 0.1 0.2 0.3 0.2]]
权重向量：
[0.2 0.25 0.18 0.22 0.15]
IFWG：
[0.4430686230851544, 0.2717241768779469]

---

2.2 直觉模糊有序几何算子

定义2.2
  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，若$\mathrm{IFOWG}$是一个映射：$F_n\to F$，使得：
$${\mathrm{IFOWG}}_w\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)={{\tilde{A}}_{\sigma (1)}}^{w_1}\oplus {{\tilde{A}}_{\sigma (2)}}^{w_2}\oplus ...\oplus {{\tilde{A}}_{\sigma (n)}}^{w_n}\text{\hspace{1em}(2.4)}$$
  则称$\mathrm{IFOWG}$为直觉模糊有序加权平均算子，其中$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$为与$\mathrm{IFOWA}$算子相关联的权重向量，$w_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{w}_j=1$，$\left(\sigma (1),\sigma (2),...,\sigma (n)\right)$为数组$\left(1,2,...,n\right)$的一个置换，使得对任意k，有${\tilde{A}}_{\sigma (k1)}\ge {\tilde{A}}_{\sigma (k)}$，即${\tilde{A}}_{\sigma (k)}$是直觉模糊数${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$按直觉模糊数的排序规则确定的第k个最大直觉模糊数。

  特别地，若$\mathbf{w}={\left(\frac{1}{n},\frac{1}{n},...,\frac{1}{n}\right)}^T$，则$\mathrm{IFOWA}$算子退化为直觉模平均$\mathrm{IFA}$算子：
$${\mathrm{IFOWA}}_w\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)=\frac{1}{n}\left({\tilde{A}}_1\oplus {\tilde{A}}_2\oplus ...\oplus {\tilde{A}}_n\right)$$

定理2.2
  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，${\tilde{A}}_{\sigma (k)}$是直觉模糊数${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$按直觉模糊数的排序规则确定的第k个最大直觉模糊数，则有$\mathrm{IFOWG}$算子运算得到的结果仍然是直觉模糊数，且

$$\underline{{\mathrm{IFOWG}}_w\left({\tilde{A}}_1,{\tilde{A}}_2,...{\tilde{A}}_n\right)=⟨\prod _{j=1}^n{\left({\mu }_{\sigma (j)}\right)}^{w_j},1-{\prod _{j=1}^n\left(1-{\nu }_{\sigma (j)}\right)}^{w_j}⟩}\text{\hspace{1em}(2.5)}$$
  其中，$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$为与$\mathrm{IFOWG}$算子相关联的权重向量，$w_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{w}_j=1$。

---

2.3 直觉模糊混合几何算子

定义2.3
  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，若$\mathrm{IFHG}$是一个映射：$F_n\to F$，使得：
$${\mathrm{IFHG}}_w\left({\tilde{A}}_1,{\tilde{A}}_2,...,{\tilde{A}}_n\right)={{\widetilde{A^{{}^{\prime }}}}_{\sigma (1)}}^{w_1}\oplus {{\widetilde{A^{{}^{\prime }}}}_{\sigma (2)}}^{w_2}\oplus ...\oplus {{\widetilde{A^{{}^{\prime }}}}_{\sigma (n)}}^{w_n}\text{\hspace{1em}(2.6)}$$
  则称$\mathrm{IFHG}$为直觉模糊混合平均算子，其中$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$为与$\mathrm{IFHG}$算子相关联的权重向量，$w_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{w}_j=1$；${\widetilde{A^{{}^{\prime }}}}_j={\left({\tilde{A}}_j\right)}^{n{\omega }_j}=⟨{{\mu }^{{}^{\prime }}}_j,{{\nu }^{{}^{\prime }}}_j⟩\left(j=1,2,...,n\right)$，$\left({\widetilde{A^{{}^{\prime }}}}_{\sigma (1)},{\widetilde{A^{{}^{\prime }}}}_{\sigma (2)},...,{\widetilde{A^{{}^{\prime }}}}_{\sigma (n)}\right)$为加权的直觉模糊数数组$\left({\widetilde{A^{{}^{\prime }}}}_1,{\widetilde{A^{{}^{\prime }}}}_2,...,{\widetilde{A^{{}^{\prime }}}}_n\right)$的一个置换，使得对任意k，有${\widetilde{A^{{}^{\prime }}}}_{\sigma (k-1)}\ge {\widetilde{A^{{}^{\prime }}}}_{\sigma (k)}$，即${\widetilde{A^{{}^{\prime }}}}_{\sigma (k)}$是直觉模糊数${\widetilde{A^{{}^{\prime }}}}_j=⟨{\mu }_j^{{}^{\prime }},{\nu }_j^{{}^{\prime }}⟩\left(j=1,2,...,n\right)$按直觉模糊数的排序规则确定的第$k$个最大直觉模糊数。$\mathbf{\omega }={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$为${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$的权重向量，${\omega }_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{\omega }_j=1$，$n$为平衡系数。

  特别地，若$\mathbf{w}={\left(\frac{1}{n},\frac{1}{n},...,\frac{1}{n}\right)}^T$，则$\mathrm{IFHG}$算子退化为直觉模糊加权几何算子$\mathrm{IFWG}$；若$\mathbf{\omega }={\left(\frac{1}{n},\frac{1}{n},...,\frac{1}{n}\right)}^T$，则$\mathrm{IFHG}$算子退化为直觉模糊有序加权几何算子$\mathrm{IFOWG}$。

定理2.3
  设${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$是一组直觉模糊数，令${\widetilde{A^{{}^{\prime }}}}_j={{\tilde{A}}_j}^{n{\omega }_j}=⟨{\mu }_j^{{}^{\prime }},{\nu }_j^{{}^{\prime }}⟩\left(j=1,2,...,n\right)$，${\widetilde{A^{{}^{\prime }}}}_{\sigma (k)}$是直觉模糊数${\widetilde{A^{{}^{\prime }}}}_j=⟨{\mu }_j^{{}^{\prime }},{\nu }_j^{{}^{\prime }}⟩\left(j=1,2,...,n\right)$中按直觉模糊数的排序规则确定的第$k$个最大直觉模糊数，则有$\mathbf{I}\mathbf{F}\mathbf{H}\mathbf{G}$算子运算得到的结果仍然是直觉模糊数，且

$$\underline{{\mathrm{IFHG}}_{\omega ,w}\left({\tilde{A}}_1,{\tilde{A}}_2,...{\tilde{A}}_n\right)=⟨1-{\prod _{j=1}^n\left(1-{\mu }_{\sigma (j)}^{{}^{\prime }}\right)}^{w_j},\prod _{j=1}^n{\left({\nu }_{\sigma (j)}^{{}^{\prime }}\right)}^{w_j}⟩}\text{\hspace{1em}(2.7)}$$

  其中，$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$为与$\mathrm{IFOWG}$算子相关联的权重向量， $w_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{w}_j=1$；
$\mathbf{\omega }={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$为${\tilde{A}}_j=⟨{\mu }_j,{\nu }_j⟩\left(j=1,2,...,n\right)$的权重向量，${\omega }_j\in [0,1]\left(j=1,2,...,n\right),{\sum }_{j=1}^n{\omega }_j=1$，$n$为平衡系数。

  $示例2.3$

  设${\tilde{A}}_1=⟨0.2,0.5⟩$，${\tilde{A}}_2=⟨0.3,0.4⟩$，${\tilde{A}}_3=⟨0.5,0.1⟩$，${\tilde{A}}_4=⟨0.7,0.2⟩$，${\tilde{A}}_4=⟨0.6,0.3⟩$为五个直觉模糊数，$\omega ={\left(0.25,0.15,0.20,0.18,0.22\right)}^T$为${\tilde{A}}_j\left(j=1,2,3,4,5\right)$的权重向量，$w={\left(0.112,0.236,0.304,0.236,0.112\right)}^T$为与$\mathrm{IFHG}$算子相关联的权重向量， 则$\mathrm{IFHG}$结果是多少？

  代码如下：

import numpy as np

def calculate_weight_IF(IF_matrix,weight_IF):
    weight_IF_ = weight_IF * IF_matrix.shape[1] # 计算<A_j_'> = (<A_j>)^(n×<w_j>)
    weighted_IF_matrix = np.zeros(IF_matrix.shape) # 初始化矩阵用于存放加权后的结果
    weighted_IF_matrix[0] = np.power(IF_matrix[0],weight_IF_)  # 计算加权后的μ_i = (<u_i>)^<w_i>
    weighted_IF_matrix[1] = 1 - np.power(1 - IF_matrix[1],weight_IF_) # 计算加权后的v_i = 1-(1-<v_i>)^<w_i>
    return weighted_IF_matrix

def IF_rank(IF_matrix):
    # 计算每个直觉模糊数的得分值score=μ-v
    score = IF_matrix[0] - IF_matrix[1]
    # 按照得分值从大到小进行重新排序
    index = np.argsort(-score)  # 获取从大到小排序索引
    IF_sequence_matrix = np.zeros(IF_matrix.shape)  # 初始化结果矩阵
    for i in range(IF_matrix.shape[1]):  # 更新结果矩阵
        IF_sequence_matrix[0][i] = IF_matrix[0][index[i]]
        IF_sequence_matrix[1][i] = IF_matrix[1][index[i]]
    return score,IF_sequence_matrix,index

def calculate_IFHG(IF_sequence_matrix,weight):
    IFHG = [1,1]
    for i in range(IF_sequence_matrix.shape[1]):
        IFHG[0] *= np.power(IF_sequence_matrix[0][i],weight[i])
        IFHG[1] *= np.power(1-IF_sequence_matrix[1][i],weight[i])
    IFHG[1] = 1 - IFHG[1]
    return IFHG
# 输入
IF_matrix = np.array([[0.2,0.3,0.5,0.7,0.6],[0.5,0.4,0.1,0.2,0.3]])
weight_IF = np.array([0.25,0.15,0.20,0.18,0.22])
weight_IFHA = np.array([0.112,0.236,0.304,0.236,0.112])

# S1: 计算加权直觉模糊数A_j_'
weighted_IF_matrix = calculate_weight_IF(IF_matrix,weight_IF)
print('Weighted_IF_matrix：\n',weighted_IF_matrix)
# S2：计算A_j_'的得分值
# S3：排序
ranked_IF = IF_rank(weighted_IF_matrix)
print('\nscores: {}\nRanked_IF：{}\nindex: {}\n'.format(ranked_IF[0],ranked_IF[1],ranked_IF[2]+1))
# S4：计算IFHA
IFHG = calculate_IFHG(ranked_IF[1],weight_IFHA)
print('\nIFHG：\n',IFHG)

  计算结果如下：

Weighted_IF_matrix：
[[0.13374806 0.40536005 0.5 0.72541785 0.57012013]
[0.57955179 0.31826838 0.1 0.18194785 0.32452723]]
scores: [-0.44580373 0.08709167 0.4 0.54346999 0.2455929 ]
Ranked_IF：[[0.72541785 0.5 0.57012013 0.40536005 0.13374806]
[0.18194785 0.1 0.32452723 0.31826838 0.57955179]]
index: [4 3 5 2 1]
IFHG：
[0.44540105671448443, 0.2981859482602651]

---

2.4 基于直觉模糊混合几何算子的多属性决策步骤

  基于直觉模糊混合几何算子的多属性决策步骤
  步骤 1 确定多属性决策问题的方案集 Y = { Y 1 , Y 2 , . . . , Y m } Y=\left\{Y_{1},Y_{2},...,Y_{m}\right\} Y={Y1​,Y2​,...,Ym​}和属性集 G = { G 1 , G 2 , . . . , G n } G=\left\{G_{1},G_{2},...,G_{n}\right\} G={G1​,G2​,...,Gn​}。
  步骤 2 获取多属性决策问题中各方案$Y_i\in Y$关于属性$G_j\in G$的直觉模糊特征信息，构建直觉模糊决策矩阵$F$。
  步骤 3 确定多属性决策问题各属性的权重，得到属性权重向量$\mathbf{\omega }={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$。
  步骤 4 利用正态分布赋权法等确定与$\mathrm{IFHA}$算子相关联的权重向量（或位置向量）$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$。
  步骤 4 利用${\mathrm{IFHG}}_{\omega ,w}\left({\tilde{A}}_1,{\tilde{A}}_2,...{\tilde{A}}_n\right)=⟨1-{{\prod }_{j=1}^n\left(1-{\mu }_{\sigma (j)}^{{}^{\prime }}\right)}^{{\omega }_j},{\prod }_{j=1}^n{\left({\nu }_{\sigma (j)}^{{}^{\prime }}\right)}^{{\omega }_j}⟩$计算方案$Y_i$的综合属性值${\tilde{d}}_i={\mathrm{IFHG}}_{w,\omega }\left(\widetilde{(}F{)}_{i1},\widetilde{(}F{)}_{i2},...,\widetilde{(}F{)}_{in},\right)$。首先利用属性权重$\mathbf{w}={\left(w_1,w_2,...,w_n\right)}^T$和平衡系数$n$计算加权的直觉模糊数${\widetilde{F^{{}^{\prime }}}}_{ij}={\tilde{F}}_{ij}\dots \dots n{w}_j$，然后利用直觉模糊数的排序规则对${\widetilde{F^{{}^{\prime }}}}_{ij}\left(j=1,2,...,n\right)$进行排序，得到直觉模糊数组${\widetilde{F^{{}^{\prime }}}}_{\sigma (1)},{\widetilde{F^{{}^{\prime }}}}_{\sigma (2)},...,{\widetilde{F^{{}^{\prime }}}}_{\sigma (n)}$；最后根据与$\mathrm{IFHG}$算子相关的权重向量$\mathbf{\omega }={\left({\omega }_1,{\omega }_2,...,{\omega }_n\right)}^T$计算方案$Y_i$的综合属性值${\tilde{d}}_i={\mathrm{IFHG}}_{w,\omega }\left({\tilde{F}}_{i1},{\tilde{F}}_{i2},...,{\tilde{F}}_{in}\right)$

---

2.5 基于直觉模糊混合几何算子的多属性决策的实例分析

  $示例2.4$

  考虑地方政府公共财政支出绩效评价问题。公共财政支出绩效评价是对财政支出活动的经济性、效率性、有效性进行评价，可以从教育支出绩效（$G_1$）、养老支出绩效（$G_2$）、就业支出绩效（$G_3$）和基础设施建设支出绩效（$G_4$）四个方面进行绩效评估。假设通过调研与专家咨询可以获得五个地区$Y_i(i=1,2,3,4,5)$关于属性$G_j(j=1,2,3,4)$的直觉模糊评价结果如下表所示。同时利用层次分析法可以得到属性$G_j(j=1,2,3,4)$的权重向量为$\omega ={(0.273,0.279,0.275,0.173)}^T$。假设由正态分布赋权法得到与$\mathrm{IFHG}$算子相关联的权重向量$w=\left(0.2,0.3,0.3,0.2\right)$

	$G_1$	$G_2$	$G_3$	$G_4$
$Y_1$	$⟨0.51,0.44⟩$	$⟨0.45,0.32⟩$	$⟨0.40,0.55⟩$	$⟨0.35,0.50⟩$
$Y_2$	$⟨0.45,0.50⟩$	$⟨0.36,0.45⟩$	$⟨0.45,0.40⟩$	$⟨0.70,0.20⟩$
$Y_3$	$⟨0.65,0.30⟩$	$⟨0.55,0.40⟩$	$⟨0.50,0.42⟩$	$⟨0.45,0.50⟩$
$Y_4$	$⟨0.60,0.25⟩$	$⟨0.75,0.15⟩$	$⟨0.65,0.25⟩$	$⟨0.50,0.35⟩$
$Y_5$	$⟨0.55,0.30⟩$	$⟨0.50,0.35⟩$	$⟨0.55,0.15⟩$	$⟨0.55,0.20⟩$

  代码如下：

import numpy as np

def calculate_weight_IF_IFHG(IF_matrix,weight_IF):
    weight_IF_ = IF_matrix.shape[1]*weight_IF # 计算<A_j_'> = (<A_j>)^(n×<w_j>)
    weighted_IF_matrix = np.zeros(IF_matrix.shape) # 初始化矩阵用于存放加权后的结果
    weighted_IF_matrix[0] = np.power(IF_matrix[0],weight_IF_)  # 计算加权后的μ_i = (<u_i>)^<w_i>
    weighted_IF_matrix[1] = 1 - np.power(1 - IF_matrix[1],weight_IF_) # 计算加权后的v_i = 1-(1-<v_i>)^<w_i>
    return weighted_IF_matrix

def IF_rank_IFHG(IF_matrix):
    # 计算每个直觉模糊数的得分值score=μ-v
    score = IF_matrix[0] - IF_matrix[1]
    # 按照得分值从大到小进行重新排序
    index = np.argsort(-score)  # 获取从大到小排序索引
    IF_sequence_matrix = np.zeros(IF_matrix.shape)  # 初始化结果矩阵
    for i in range(IF_matrix.shape[1]):  # 更新结果矩阵
        IF_sequence_matrix[0][i] = IF_matrix[0][index[i]]
        IF_sequence_matrix[1][i] = IF_matrix[1][index[i]]
    return score,IF_sequence_matrix,index

def calculate_IFHG(IF_sequence_matrix,weight):
    IFHG = [1,1]
    for i in range(IF_sequence_matrix.shape[1]):
        IFHG[0] *= np.power(IF_sequence_matrix[0][i],weight[i])
        IFHG[1] *= np.power(1-IF_sequence_matrix[1][i],weight[i])
    IFHG[1] = 1 - IFHG[1]
    return IFHG

# 输入
IF_matrix_IFHG = np.array([[[0.51,0.45,0.40,0.35],[0.44,0.32,0.55,0.50]],
                           [[0.45,0.36,0.45,0.70],[0.50,0.45,0.40,0.20]],
                           [[0.65,0.55,0.50,0.45],[0.30,0.40,0.42,0.50]],
                           [[0.60,0.75,0.65,0.50],[0.25,0.15,0.25,0.35]],
                           [[0.55,0.50,0.55,0.55],[0.30,0.35,0.15,0.20]]])
weight_IF_IFHG = np.array([0.273,0.279,0.275,0.173])
weight_IFHG = np.array([0.2,0.3,0.3,0.2])

# S1: 计算加权直觉模糊数A_j_'
weighted_IF_matrix_IFHG = []
for item in IF_matrix_IFHG:
    #print(weight_attr_4)
    weighted_IF_matrix_IFHG.append(calculate_weight_IF_IFHG(item,weight_IF_IFHG))
print('\nWeight_IF_Matrix:\n',weighted_IF_matrix_IFHG)

score_IFHG = []
ranked_IF_IFHG = []
index_IFHG = []
for item in weighted_IF_matrix_IFHG:
    tmp_rlt = IF_rank_IFHG(item)
    score_IFHG.append(tmp_rlt[0])
    ranked_IF_IFHG.append(tmp_rlt[1])
    index_IFHG.append(tmp_rlt[2])
print('\nscore: {}\nRanked_IF_IFHG：{}\nIndex_IFHG: {}'.format(score_IFHG,ranked_IF_IFHG,index_IFHG))
# S4：计算IFHA
IFHG_Result = []
for item in ranked_IF_IFHG:
    IFHG_Result.append(calculate_IFHG(item,weight_IFHG))
print('\nIFHG：\n',IFHG_Result)
# 再次排序
IFHG_Result_2 = np.array(IFHG_Result)
tmp_matrix = np.zeros((2,IFHG_Result_2.shape[0]))
for i in range(tmp_matrix.shape[1]):
    tmp_matrix[0][i] = IFHG_Result_2[i][0]
    tmp_matrix[1][i] = IFHG_Result_2[i][1]

score,final_result,index = IF_rank_IFHG(tmp_matrix)
print('\nFinal score: \n',score)
print('\nFinal Result: \n',final_result)
print('Final Index: \n',index+1)

  计算结果如下：

Weight_IF_Matrix:
[array([[0.47936534, 0.41019009, 0.36497741, 0.48360979],
[0.46908949, 0.34975062, 0.58453565, 0.38100485]]), array([[0.41812686, 0.31976696, 0.41546435, 0.78128204],
[0.5308894 , 0.48684949, 0.42987987, 0.14308396]]), array([[0.62474298, 0.51315051, 0.4665165 , 0.57547049],
[0.32259709, 0.43452059, 0.45074908, 0.38100485]]), array([[0.57245475, 0.72538466, 0.62259366, 0.61899515],
[0.26958968, 0.16587426, 0.27126876, 0.25777421]]), array([[0.52056631, 0.46137125, 0.51808254, 0.66119716],
[0.32259709, 0.38168283, 0.16370246, 0.14308396]])]
score: [array([ 0.01027586, 0.06043947, -0.21955823, 0.10260494]), array([-0.11276254, -0.16708253, -0.01441552, 0.63819808]), array([0.30214589, 0.07862991, 0.01576742, 0.19446564]), array([0.30286507, 0.5595104 , 0.3513249 , 0.36122094]), array([0.19796922, 0.07968842, 0.35438008, 0.5181132 ])]
Ranked_IF_IFHG：[array([[0.48360979, 0.41019009, 0.47936534, 0.36497741],
[0.38100485, 0.34975062, 0.46908949, 0.58453565]]), array([[0.78128204, 0.41546435, 0.41812686, 0.31976696],
[0.14308396, 0.42987987, 0.5308894 , 0.48684949]]), array([[0.62474298, 0.57547049, 0.51315051, 0.4665165 ],
[0.32259709, 0.38100485, 0.43452059, 0.45074908]]), array([[0.72538466, 0.61899515, 0.62259366, 0.57245475],
[0.16587426, 0.25777421, 0.27126876, 0.26958968]]), array([[0.66119716, 0.51808254, 0.52056631, 0.46137125],
[0.14308396, 0.16370246, 0.32259709, 0.38168283]])]
Index_IFHG: [array([3, 1, 0, 2], dtype=int64), array([3, 2, 0, 1], dtype=int64), array([0, 3, 1, 2], dtype=int64), array([1, 3, 2, 0], dtype=int64), array([3, 2, 0, 1], dtype=int64)]
IFHG：
[[0.43395805570821366, 0.4460448768044488], [0.44820927151279855, 0.42877251908288205], [0.5419934328192367, 0.4010993532851309], [0.6301290295254321, 0.24683398721603678], [0.5322783547272674, 0.2573361600206997]]
Final score:
[-0.01208682 0.01943675 0.14089408 0.38329504 0.27494219]
Final Result:
[[0.63012903 0.53227835 0.54199343 0.44820927 0.43395806]
[0.24683399 0.25733616 0.40109935 0.42877252 0.44604488]]
Final Index:
[4 5 3 2 1]