【综合评价】投影寻踪模型

小黑student

已于 2023-09-17 17:51:17 修改

阅读量2.7k

点赞数 9

文章标签： python

于 2023-09-15 17:27:53 首次发布

本文链接：https://blog.csdn.net/m0_69321141/article/details/132807004

版权

投影寻踪模型

模型的介绍
方法步骤
基于RAGA的投影寻踪模型
Python代码实现
参考资料

模型的介绍

投影寻踪模型是基于降维的手段计算投影的特征值，将高维的空间映射到低维空间上，寻找一种能反映出高维数据信息的模型。在众多评价类模型中，它在稳健性、抗干扰性和准确性都较优异。

方法步骤

评价指标的确立

这部分的自由度相对较广，每个人对同一数据的分析与理解都不同，所创造出的指标不同。但指标确立的好坏，影响着最后样本间的排名

数据正向化和归一化

指标可以分为以下几类：效益型指标、成本型指标、中间型指标和区间型指标
效益型指标：数值越大越好，比如销量、成绩
成本型指标：数值越小越好，比如采购成本、差评数量
中间型指标：数值不需要太大（太小），取某个特定值( $x_{best}$ )时最好，比如水的PH值
区间型指标：数值在某个[a, b]区间范围内最好，比如体温

正向化

各指标类型转效益型指标的方法

指标类型	转化方式
成本型指标	$\frac{1}{x}(x不为0) 或 max(x)-x$
中间型指标	$x_i = 1 - \frac{\|x_i - x_{best}\|}{max(\|x_i- x_{best}\|)} , i=1,2,...,n$
区间型指标	$M=\max \left\{a-\min \left\{x_{i}\right\}, \max \left\{x_{i}\right\}-b\right\}, \tilde{x}_{i}=\left\{\begin{array}{l}1-\frac{a-x_{i}}{M}, x_{i}<a \\1, a \leqslant x_{i} \leqslant b \\1-\frac{x_{i}-b}{M}, x_{i}>b\end{array}\right.$

归一化

指标类型	归一化
效益型指标	$x_{ij} = \frac{x_{ij} - min(x_j)}{max(x_j) - min(x_j)}$
成本型指标	$x_{ij} = \frac{max(x_j) - x_{ij}}{max(x_j) - min(x_j)}$
区间型指标	$x_{i j}=\left\{\begin{array}{cc}1-\left(x_{\mathrm{op}}-x_{i j}\right) /\left(x_{\mathrm{op}}-a_{j}^{\prime}\right) &a_{j}^{\prime} \leqslant x_{i j} \leqslant x_{\mathrm{op}} \\1-\left(x_{i j}-x_{\mathrm{op}}\right) /\left(a_{j}^{\prime \prime}-x_{\mathrm{op}}\right) &x_{\mathrm{op}}<x_{i j} \leqslant a_{j}^{\prime \prime} \\0 & x_{i j}<a_{j}^{\prime} \text { 或 } x_{i j}>a_{j}^{\prime \prime}\end{array}\right.$ 其中 $x_{op}$ 为最优属性值，[ $a_{j}^{\prime}$ , $a_{j}^{\prime \prime}$ ]为无法容忍的上下界¹

这里只是其中一种归一化方式，常见的还有Z-score( $x_{ij}=\frac{x_{ij} - \bar{x} }{\sigma_x}$ )，线性比例法( $x_{ij}=\frac{x_{ij}}{R_j}$ , $R_j$ 为缩放比例)

建立投影指标函数

由于该模型是将复杂数据高维投影到低维空间，其求解过程，就是寻找最佳的投影方向
$\vec{a} = (a(1), a(2), \dots, a(p))$
其中 $a$ 为单位长度向量(确保结果只受投影方向影响，即 $\sum_{j=1}^{p}a^2(j)=1$ )，p为指标个数，也就是各指标对应的权重大小，从而得到投影值 $z (i)$
$\sum_{j=1}^{p}a(j)x(i,j)$
投影值z的分布特征是投影指标函数构造的依据，要整体分散，局部密集，因此可以构造为²
$S_zD_z\\ s.t.\begin{cases} S_{z}=\sqrt{\frac{\sum_{i=1}^{n}(z(i)-E(z))^{2}}{n-1}} \\ D_{z}=\sum \sum_{i}^{n}(R-r(i, j)) \times u(R-r(i, j)) \end{cases}$
$E (z)$ 为投影值z的平均值， $S_z$ 就是样本标准差， $R$ 为局部密度的窗口半径，可以根据试验进行确定，一般来说 $R=0.1S_z$ 。 $D_z$ 是投影 $z$ 的局部密度， $r (i, j) = ∣ z (i) - z (j) ∣$ ， $u (t)$ 为单位阶跃函数， $\ge 0$ ， $u (t) = 1$ ； $t < 0$ ， $u (t) = 0$

优化投影指标函数

投影方向 $\bar{a}$ 的变化会导致 $Q (a)$ 的变化，因此要在低维空间上更有效的反映高维数据的特点的投影方向，即让指标函数 $Q (a)$ 最大化
$S_z * D_z \\ s.t.\sum_{j=1}^{p}a^2(j)=1, a(j)\ge0$
求出最佳的投影方向 $\bar{a}$ 并代入 $z (i)$ 的公式当中得到各个样本的投影值，这也就是最终的样本评价值，再进行分析即可。
那么对于上述问题，如何求解最优解 $\bar{a}$ ？这是一个复杂非线性的问题，基于众多论文都是采用加速遗传算法³求解该问题，本篇文章也不例外。

基于RAGA的投影寻踪模型

优化实数编码

若 $\in [a(j), b(j)]$ ，采用线性变 $x (j) = a (j) + y (j) * (b (j) - a (j))$ ，其中 $y (j)$ 表示第j个基因。这一步其实就是归一化操作

初始种群

设定种群数量 $n$ ，随机初始化 $n$ 个个体 $y_i = (y(1), y(2), \dots ,y(j)), i=1,2,...,n， j=1,2,\dots,p$ ，但要满足 $y(j)\in [0,1]$ 且 $\sum_{j=1}^{p}y^2(j)=1$ ，也就是上式的约束条件。然后代入到上式 $Q (a)$ ，按照从大到小排序，对应个体也排序。

适应度评价函数

其目的就是为了让染色体的选择概率与其适应度成正比。这里使用基于序的评价函数²（ $e v a l (y (i))$ 表示），具体公式如下 $\alpha (1-\alpha)^{i-1}, i=1,2,\dots,n$
其中 $\alpha \in (0,1)$ ，一般 $\alpha=0.05$ [^4]，当 $i = 1$ 染色体最好，当 $i = n$ 染色体最差。

选择下一代个体

设置进入下一代个体数为N，每个染色体 $y (i)$ 的累积概率 $q_i$ 为
$\begin{cases}q_0=0 \\q_i=\sum_{k=1}^{i}eval(y(k)),i=1,2,\dots,N \end{cases}$
从区间 $0, q_i]$ 产生随机数r，如果 $q_{i-1}<r\le q_i$ ，就选择第i个个体，重复N次。

杂交

选出N个个体后，随机两两配对，如果个体总数为奇数不足以配对，可以删除(或添加)一个染色体。对于每个配对 $y_1, y_2$ ，产生[0,1]随机数 $r$ ，定义 $P_c$ 为交叉概率，如果 $r < P_c$ 则进行交叉，从(0,1)产生随机数c，获得的两个后代为
$X = c * y_1 + (1-c)*y_2\\ Y=(1-c)*y_1 + c*y_2$
这里还要检验后代的可行性，检验他们是否满足 $∣∣ X ∣∣ = 1, ∣∣ Y ∣∣ = 1$ ，即是否为单位长度向量，不是的话可以使用一些改进策略。再将交叉后可行的后代与未选择的父代作为一个群体进入下一操作。

变异

与杂交很相似，设定变异参数 $P_m$ ，对于杂交后的每个个体，在[0,1]产生随机数 $r$ ，如果 $r < P_m$ ，随机生成p维向量d，按照
$y_i^* = y_i + Md$
其中 $M$ 是一个足够大的数，如果在给定的迭代次数中没有可行解( $y_i^*||=1$ )，那么M=0，相当于不变。对每一个个体都进行如此操作，进入下一代。

演化迭代

按照适应度( $Q (a)$ )从大到小排序，选择序列前n个个体进入下一次迭代

加速循环

设置加速次数，根据加速次数获得的群体，按适应度选取前 $m$ 个个体，将他们染色体值所在区间作为新一轮初始化种群的变化区间。直至到达迭代次数，获得最佳的投影方向。

Python代码实现

以下为关键部分的代码实现

class RAGA():
    def __init__(self, N=50, Pm=0.8, Pc=0.8, alpha=0.05, num_iters=10):
        self.N = N #选择个数
        self.Pm = Pm #变异概率
        self.Pc = Pc #交叉概率
        self.alpha = alpha #基于序的评价函数α,见[2]
        self.num_iters = num_iters
        
    def fit(self, X):
        p = X.shape[1]
        min_v = np.zeros(p, )
        max_v = np.ones(p, )
        #初始化种群
        for epoch in range(self.num_iters):
            a = self.init_population(self.N, p, min_v, max_v)
            for k in range(2): #加速次数为2
                Q = np.zeros(self.N, )
                for i in range(self.N):
                    Q[i] = self.cal_Q(X, a[i])
                Q1 = sorted(Q, reverse=True)
                y = a[np.argsort(-Q)]
                #基于序的评价函数
                q = np.zeros(self.N, )
                for i in range(1, self.N):
                    q[i] = q[i-1] + self.alpha * (1 - self.alpha) ** (i - 1)
                #选择
                a2 = np.zeros((self.N, p))
                for i in range(self.N):
                    r = np.random.uniform(0, q[self.N-1])
                    for j in range(1, self.N):
                        if r > q[j-1] and r <= q[j]:
                            a2[i] = y[j]
                #杂交
                while True:
                    a3 = []
                    chooseid = []
                    for i in range(self.N):
                        r = np.random.rand()
                        if r < self.Pc:
                            a3.append(a2[i])
                            chooseid.append(i)
                    #保证有偶数个父代
                    if len(a3) !=0 and len(a3) % 2 == 0:
                        break
                a3 = np.array(a3)
                #剩余未被选中的父代
                a3temp = np.delete(a2, chooseid, axis=0)
                #随机配对
                a3 = np.random.permutation(a3)
                a4 = np.zeros_like(a3)
                for i in range(0, len(a3), 2):
                    while True:
                        c = np.random.rand() #随机生成0-1任意数c
                        #获得两个后代
                        Y1 = c * a3[i] + (1 - c) * a3[i+1]
                        Y2 = (1 - c) * a3[i] + c * a3[i+1]
                        #可行性检验
                        temp1 = sum(Y1**2)
                        temp2 = sum(Y2**2)
                        a4[i] = np.sqrt(Y1**2 / temp1)
                        a4[i+1] = np.sqrt(Y2**2 / temp2)
                        if abs(sum(a4[i]**2) - 1) < 1e-5 and abs(sum(a4[i+1]**2) - 1) < 1e-5:
                            break
                a5 = np.concatenate((a3temp, a4), axis=0) #后代和剩余父代合并
                #变异
                while True:
                    a6 = []
                    chooseid = []
                    for i in range(self.N):
                        r = np.random.rand()
                        if r < self.Pm:
                            a6.append(a5[i])
                            chooseid.append(i)
                    if len(chooseid) != 0:
                        break
                a6 = np.array(a6)
                a6temp = np.delete(a5, chooseid, axis=0) #剩余未变异的个体
                d = np.random.uniform(-1, 1, p)
                M = 10
                for i in range(len(a6)):
                    muNo = 0
                    while True: #给定迭代次数
                        muNo += 1
                        mu = a6[i] + M * d #变异操作
                        mu_temp = np.sqrt((a6[i] + M * d) ** 2 / sum((a6[i] + M * d) ** 2))
                        if muNo == 100: #达到迭代次数还未可行时，不变异
                            break
                        elif abs(sum(mu_temp**2) - 1) < 1e-5: #可行->变异
                            a6[i] = mu_temp
                            break
                a = np.concatenate((a6, a6temp), axis=0) #合并
            #加速次数结束
            #适应度排序
            Q = np.zeros(self.N, )
            for i in range(self.N):
                Q[i] = self.cal_Q(X, a[i])
            Q1 = sorted(Q, reverse=True)
            y = a[np.argsort(-Q)]
            y2 = y[:20] #选取前20个作为优秀个体
            min_v = y2.min(axis=0) #缩小搜索区域，加快算法收敛
            max_v = y2.max(axis=0)
        #达到加速次数
        Q = np.zeros(self.N, )
        for i in range(self.N):
            Q[i] = self.cal_Q(X, a[i])
        best_Q = Q[np.argmax(Q)]
        best_a = a[np.argmax(Q)]
        return best_Q, best_a
        
    def init_population(self, n, p, min_v, max_v):
        '''
        n: 父代群体个数
        p: 优化变量数目
        '''
        pops = np.zeros((n, p))
        for i in range(n):
            while True:
                pop = np.random.uniform(min_v, max_v) #生成0-1均匀分布的随机数
                temp = np.sum(pop**2)
                a = np.sqrt(pop ** 2 / temp) #n组，每组p个指标的权重
                if abs(sum(a**2) - 1) < 1e-5:
                    pops[i] = a
                    break
        return pops

    def cal_S(self, Z): #计算样本标准差
        n = len(Z)
        S = np.sqrt(sum((Z - Z.mean()) ** 2) / (n - 1))
        return S
    
    def cal_u(self, t): #单位阶跃函数
        if t >= 0:
            return 1
        else:
            return 0
    
    def cal_Q(self, X, a): #计算投影指标函数
        Z = np.dot(X, a) #计算投影值
        S = self.cal_S(Z)
        R = 0.1 * S #见论文
        D = 0 #投影值的局部密度
        
        n = len(Z)
        for i in range(n):
            for j in range(n):
                rij = abs(Z[i] - Z[j])
                t = R - rij
                u = self.cal_u(t)
                D += t * u
        Q = S * D
        return Q

参考资料

罗宁,贺墨琳,高华,姜志筠,张天东,赵佳伟,吴国鼎,李智,胡钋.基于改进的AHP-CRITIC组合赋权与可拓评估模型的配电网综合评价方法[J].电力系统保护与控制,2021,49(16):86-96.DOI:10.19783/j.cnki.pspc.201235 ↩︎
苏屹,于跃奇.基于加速遗传算法投影寻踪模型的企业可持续发展能力评价研究[J].运筹与管理,2018,27(05):130-139. ↩︎ ↩︎
王淑娟.基于投影寻踪模型和加速遗传算法的石羊河流域水资源承载力综合评价[J].地下水,2009,31(06):82-84. ↩︎