优化方法1

---

前言

This week,the paper which describes that a deep generative model based on LSTM is developed for multi-step solar irradiation prediction at least 24 h in the future has been read. Then I learn the ant colony algorithm and understand the basic idea and algorithm steps of ant colony algorithm.

本周阅读文献《Multi-step solar irradiation prediction based on weather forecast and generative deep learning model》，主要介绍了基于LSTM的深度生成模型，用于未来至少24 h的多步太阳辐照预测；另外学习了蚁群算法，了解了蚁群算法的基本思路和算法步骤。

---

文献阅读

题目：Multi-step solar irradiation prediction based on weather forecast and generative deep learning model
作者：Gao, Y (Gao, Yuan) ; Miyata, S (Miyata, Shohei); Akashi, Y (Akashi, Yasunori)

摘要

随着计算机技术的飞速发展，越来越多的深度学习模型被用于太阳辐射预测。然而，由于时间序列的复杂性和多步预测误差的累积，如何将深度学习模型更好地应用于建筑能源系统的优化方法中，仍然是一个具有挑战性的问题。本研究建立了基于LSTM的深度生成模型，用于未来至少24 h的多步太阳辐照预测。实验使用气象厅的测量数据和温度预报数据进行训练和测试。结果表明，先生成模型可以有效避免误差累积问题。与传统的回归 LSTM 模型相比，生成模型可以产生 7.7% 的准确率提升。其次，引入前一天的温度预报数据，可以将预报准确率提高约18个百分点。当使用较早的温度预报时，预报精度会逐渐降低，使用3天前发布的温度预报很难提高预报效果。最后，使用每小时温度预测将比使用每日温度预测获得更好的预测准确性。

本文主要研究以下几点：

1. 利用LSTM网络构建适用于多步预测的深度生成模型。模型结构避免了误差的累积，生成模型可以通过多重抽样降低异常值预测的概率。与多步回归模型相比，生成模型生成的未来预测长度也更加灵活。
2. 实验设计详细讨论了使用不同日期发布的天气预报数据（提前一到七天发布的天气预报）对最终太阳辐射预测的影响。此外，还对每小时温度预报和每日温度预报之间的差异进行了补充实验。
3. 天气预报数据的使用进一步减少，仅使用温度预报来降低数据采集难度和真实MPC中模型部署的成本。

模型构建和细节

由于本研究将使用深度网络方法构建模型，考虑到深度网络强大的非线性拟合能力，假设时间序列的特征只能完全由两个因素表示，如下面的方程yt=gt+rt，其中 gt指时间序列数据的所有稳定信息，包括时间序列的长期趋势和季节性趋势，深度网络可以拟合包括长期趋势和短期趋势在内的所有信息，称为全局项;rt表示不同时间步长的随机效应，虽然模型在全局项上拟合了长期和季节性趋势，但考虑到时间序列的整体复杂性和不确定性，仍然需要添加随机效应（rt） 以更好地拟合时间序列数据。

基于生成模型和长期短期模因（LSTM）定义的最终辐照预测生成模型的构建，需要对全局分量gt和随机分量 rt分别建模。之后，使用计算结果构建分布和样本以生成最终预测结果。
本节中，作者需要完成基于生成模型和长期短期模因（LSTM）定义的最终辐照预测生成模型的构建。由于篇幅所限，LSTM的相关内容和计算公式见附录。首先，根据方程（5）的内容，我们需要对全局分量g进行建模t和随机分量 rt分别。之后，使用计算结果构建分布和样本以生成最终预测结果。

评估方法和训练损失函数

由于本文假设先验分布是高斯分布，因此损失函数也使用高斯似然损失函数。通过计算模型输出的平均值和标准差与实际辐照观测值，模型可以通过梯度下降正确更新模型中的所有权重。具体计算方法如下。

模型定义
模型使用LSTM网络和回归模型来预测太阳辐射。该模型通过LSTM网络对当前长度序列进行编码，并在下一个时间步预测太阳辐射预测结果，如下图所示。

结果与讨论

M.1 使用回归模型来预测整个测试集。由于 M.1 和 M.2 模型仅使用某些已知特征进行预测，因此 M.2 模型的采样窗口大小不会影响结果的比较。从表2中的结果可以看出，在整个测试集中，M.2模型比M.1模型降低了7.7%的MAPE点。可以看出，与传统的回归迭代模型相比，生成模型在相同数据下可以获得更好的预测结果。由于 M.2 仅使用 LSTM 网络，与M.2模型相比，只有M.3中采用真实温度和提前一天发布的温度预测的模型比M.2取得了更好的结果。当使用前一天的预测时，改进变为 18% 点。在使用真实温度数据的情况下，与使用 LSTM 模型的 M.3 相比，使用 LSTM 模型的 M.5 也将测试集的 MAPE 性能提高了 18.94%;在 Bi-LSTM 的情况下，M.6 将 M.4 的结果增加了 23.87%。

优化方法

蚁群算法：一种用来在图中寻找优化路径的机率型算法。

思路

要有洞穴cave，也就是蚂蚁的初始位置，有可能在同一点，也有可能随机散布在各处；蚂蚁刚开始寻找食物时是按照随即方向走的，有一只蚂蚁找到食物就会留下信息素寻找回家的路径，在附近的蚂蚁看到信息素也会跟着去找食物，最开始的蚂蚁找到回家的路径上的信息素会越多；这个算法重要的两个点是强化和随机，要强化局部最优但同时又不能陷在局部最优中，所以要保留一定的随机性，但有蚂蚁不随着信息素走，找到更短路径，留下的信息素更浓，这个信息素是会挥发的，迭代一定的次数会找到最短路径。它的缺点是很容易陷入局部最优解，收敛速度慢。

参数

挥发速度ρ：确定信息素路径的挥发速度，默认是0.5 ；增加该值会导致算法尝试新的解，而不是优化当前解。

权衡强化和随机之间的两个因子

alpha：（信息启发式因子）信息素踪迹的吸引力，就是蚂蚁看到信息素，信息素对它的吸引力大不大，吸引力不大就会按照之前设定的随机方向走，随机性更大，值比较大那么强化因子比较大。

beta：设置更好的状态转换（从一个节点到另一个节点）的吸引力，值越大意味着信息素更浓的那条路的吸引力更大。

蚁群算法的全局寻优性能首先要求蚁群的搜索过程要有强的随机性，以及快速收敛的性能，因此要在alpha和beta之间选取一个平衡点。

ant_count：算法中的蚂蚁数量，数量过大每条路径上的信息素趋于平均，导致收敛速度变慢，过小导致未搜索过的路径信息素浓度减小，收敛过早，全局最优解降低。
q：控制一次行程中路径的所有节点共享的信息素数量。过多使得蚁群的搜索范围减小过早收敛，陷入局部最优；过小每条路径上的信息含量差别较小，容易陷入混沌状态。

算法:
1.初始化(各个参数): 在计算之初需要对相关的参数进行初始化，如蚂蚁数量m、信息素因子α、启发函数因子β、信息素挥发因子ρ、信息素常数Q、最大迭代次数t等等。
2.构建解空间： 将各个蚂蚁随机地放置于不同的出发点，对每个蚂蚁k（k=1，2，……，m），计算其下一个待访问的城市，直到所有蚂蚁访问完所有的城市。
3.更新信息素： 计算各个蚂蚁经过的路径长度L，记录当前迭代次数中的最优解（最短路径）。同时，对各个城市连接路径上的信息素浓度进行更新。
4.判断是否终止： 若迭代次数小于最大迭代次数则迭代次数加一，清空蚂蚁经过路径的记录表，并返回步骤二；否则终止计算，输出最优解。

转移概率公式：

P^k_ij(t)：表示第T代蚂蚁中第K只蚂蚁选择从i-j的概率。

信息素更新公式

蚁群算法解决旅行商问题

import numpy as np
import matplotlib.pyplot as plt


# 城市坐标(52个城市)
coordinates = np.array([[565.0,575.0],[25.0,185.0],[345.0,750.0],[945.0,685.0],[845.0,655.0],
            [880.0,660.0],[25.0,230.0],[525.0,1000.0],[580.0,1175.0],[650.0,1130.0],
            [1605.0,620.0],[1220.0,580.0],[1465.0,200.0],[1530.0,  5.0],[845.0,680.0],
            [725.0,370.0],[145.0,665.0],[415.0,635.0],[510.0,875.0],[560.0,365.0],
            [300.0,465.0],[520.0,585.0],[480.0,415.0],[835.0,625.0],[975.0,580.0],
            [1215.0,245.0],[1320.0,315.0],[1250.0,400.0],[660.0,180.0],[410.0,250.0],
            [420.0,555.0],[575.0,665.0],[1150.0,1160.0],[700.0,580.0],[685.0,595.0],
            [685.0,610.0],[770.0,610.0],[795.0,645.0],[720.0,635.0],[760.0,650.0],
            [475.0,960.0],[95.0,260.0],[875.0,920.0],[700.0,500.0],[555.0,815.0],
            [830.0,485.0],[1170.0, 65.0],[830.0,610.0],[605.0,625.0],[595.0,360.0],
            [1340.0,725.0],[1740.0,245.0]])

def getdistmat(coordinates):
    num = coordinates.shape[0]
    distmat = np.zeros((52, 52))
    for i in range(num):
        for j in range(i, num):
            distmat[i][j] = distmat[j][i] = np.linalg.norm(
                coordinates[i] - coordinates[j])
    return distmat


# #//初始化
distmat = getdistmat(coordinates)
numant = 45 ##// 蚂蚁个数
numcity = coordinates.shape[0] ##// 城市个数
alpha = 1 ##// 信息素重要程度因子
beta = 5 ##// 启发函数重要程度因子
rho = 0.1 ##// 信息素的挥发速度
Q = 1 ##//信息素释放总量
iter = 0##//循环次数
itermax = 200#//循环最大值
etatable = 1.0 / (distmat + np.diag([1e10] * numcity)) #// 启发函数矩阵，表示蚂蚁从城市i转移到矩阵j的期望程度
pheromonetable = np.ones((numcity, numcity)) #// 信息素矩阵
pathtable = np.zeros((numant, numcity)).astype(int) #// 路径记录表
distmat = getdistmat(coordinates) #// 城市的距离矩阵
lengthaver = np.zeros(itermax) #// 各代路径的平均长度
lengthbest = np.zeros(itermax) #// 各代及其之前遇到的最佳路径长度
pathbest = np.zeros((itermax, numcity)) #// 各代及其之前遇到的最佳路径长度
#//核心点-循环迭代
while iter < itermax:
    #// 随机产生各个蚂蚁的起点城市
    if numant <= numcity:
        #// 城市数比蚂蚁数多
        pathtable[:, 0] = np.random.permutation(range(0, numcity))[:numant]
    else:
        #// 蚂蚁数比城市数多，需要补足
        pathtable[:numcity, 0] = np.random.permutation(range(0, numcity))[:]
        pathtable[numcity:, 0] = np.random.permutation(range(0, numcity))[
            :numant - numcity]
    length = np.zeros(numant)  # 计算各个蚂蚁的路径距离
    for i in range(numant):
        visiting = pathtable[i, 0]  # 当前所在的城市
        unvisited = set(range(numcity))  # 未访问的城市,以集合的形式存储{}
        unvisited.remove(visiting)  # 删除元素；利用集合的remove方法删除存储的数据内容
        for j in range(1, numcity):  # 循环numcity-1次，访问剩余的numcity-1个城市
            # 每次用轮盘法选择下一个要访问的城市
            listunvisited = list(unvisited)
            probtrans = np.zeros(len(listunvisited))
            for k in range(len(listunvisited)):
                probtrans[k] = np.power(pheromonetable[visiting][listunvisited[k]], alpha) \
                    * np.power(etatable[visiting][listunvisited[k]], beta)
            cumsumprobtrans = (probtrans / sum(probtrans)).cumsum()
            cumsumprobtrans -= np.random.rand()
            k = listunvisited[(np.where(cumsumprobtrans > 0)[0])[0]]
            # 元素的提取（也就是下一轮选的城市）
            pathtable[i, j] = k  # 添加到路径表中（也就是蚂蚁走过的路径)
            unvisited.remove(k)  # 然后在为访问城市set中remove（）删除掉该城市
            length[i] += distmat[visiting][k]
            visiting = k
        # 蚂蚁的路径距离包括最后一个城市和第一个城市的距离
        length[i] += distmat[visiting][pathtable[i, 0]]
        # 包含所有蚂蚁的一个迭代结束后，统计本次迭代的若干统计参数
    lengthaver[iter] = length.mean()
    if iter == 0:
        lengthbest[iter] = length.min()
        pathbest[iter] = pathtable[length.argmin()].copy()
    else:
        if length.min() > lengthbest[iter - 1]:
            lengthbest[iter] = lengthbest[iter - 1]
            pathbest[iter] = pathbest[iter - 1].copy()
        else:
            lengthbest[iter] = length.min()
            pathbest[iter] = pathtable[length.argmin()].copy()
    # 更新信息素
    changepheromonetable = np.zeros((numcity, numcity))
    for i in range(numant):
        for j in range(numcity - 1):
            changepheromonetable[pathtable[i, j]][pathtable[i, j + 1]] += Q / distmat[pathtable[i, j]][
                pathtable[i, j + 1]]  # 计算信息素增量
        changepheromonetable[pathtable[i, j + 1]][pathtable[i, 0]] += Q / distmat[pathtable[i, j + 1]][pathtable[i, 0]]
    pheromonetable = (1 - rho) * pheromonetable + \
        changepheromonetable  # 计算信息素公式
    if iter%30==0:
        print("iter(迭代次数):", iter)
    iter += 1  # 迭代次数指示器+1

# 做出平均路径长度和最优路径长度
fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(12, 10))
axes[0].plot(lengthaver, 'k', marker=u'')
axes[0].set_title('Average Length')
axes[0].set_xlabel(u'iteration')

axes[1].plot(lengthbest, 'k', marker=u'')
axes[1].set_title('Best Length')
axes[1].set_xlabel(u'iteration')
fig.savefig('average_best.png', dpi=500, bbox_inches='tight')
plt.show()

# 作出找到的最优路径图
bestpath = pathbest[-1]
plt.plot(coordinates[:, 0], coordinates[:, 1], 'r.', marker=u'$\cdot$')
plt.xlim([-100, 2000])
plt.ylim([-100, 1500])

for i in range(numcity - 1):
    m = int(bestpath[i])
    n = int(bestpath[i + 1])
    plt.plot([coordinates[m][0], coordinates[n][0]], [
             coordinates[m][1], coordinates[n][1]], 'k')
plt.plot([coordinates[int(bestpath[0])][0], coordinates[int(n)][0]],
         [coordinates[int(bestpath[0])][1], coordinates[int(n)][1]], 'b')
ax = plt.gca()
ax.set_title("Best Path")
ax.set_xlabel('X axis')
ax.set_ylabel('Y_axis')

plt.savefig('best path.png', dpi=500, bbox_inches='tight')
plt.show()

---

总结

本周学习和了解了蚁群算法的主要思想和算法步骤，下周继续了解其他的优化算法。