目录

一、多尺度排列熵原理

1.1 排列熵（PE）

1.2 多尺度排列熵（MPE）

1.3 参数对MPE的影响

二、参数优化方法

2.1 遗传算法（GA）

2.2 粒子群优化算法（PSO）

2.3 多作用力粒子群优化算法（MFPSO）

三、多尺度排列熵参数优化

3.1 适应度函数的确定

3.2 参数优化过程

四、MATLAB源代码

参考文献

一、多尺度排列熵原理

1.1 排列熵（PE）

排列熵算法原理及MATLAB代码见地址：排列熵、模糊熵、近似熵、样本熵的原理及MATLAB实现

排列熵只能检测时间序列在单一尺度上的复杂性和随机性。复杂系统的输出时间序列在多重尺度上包含特征信息，为研究时间序列的多尺度复杂性变化，排列熵分析不再满足。

1.2 多尺度排列熵（MPE）

对长度为  的时间序列进行粗粒化处理得到粗粒化序列，其表达式为：



其中， 为尺度因子，。 表示对 N/s 取整，当 =1 时，粗粒化序列即为原始序列。

对每个粗粒化序列，计算其排列熵即可得到多尺度排列熵。多尺度排列熵的计算流程如图1所示，具体步骤如下：

（1）将时间序列粗粒化处理；

（2）对每个粗粒化序列相空间重构； 

（3）重构分量按升序排列，计算每一种符号序列出现的概率；

（4）根据式（1-1）计算每个粗粒化序列的排列熵，并进行归一化处理，进而得到多尺度排列熵值。




1.3 参数对MPE的影响

在粗粒化环节中，尺度因子的选择尤为重要，若尺度因子  取值过小，则不能最大限度的提取信号的特征信息；若  取值过大，将有可能造成信号之间的复杂度差异被抹除。同时，在多尺度排列熵的计算过程中，若嵌入维数  取值太小，算法的突变检测性能降低；若嵌入维数  取值太大，将无法反应时间序列的细微变化。而且，时间序列长度  与延迟时间  对多尺度排列熵算法也有着不同的影响。

计算不同长度信号在不同嵌入维数m下的MPE值，如图 2(a)~2(d)所示。







 







 

信号长度N=1024，嵌入维数m=6，尺度因子s=12，如图 3 所示为计算信号在不同延迟时间 t 值下的MPE值。




 信号长度N=1024，嵌入维数m=6，延迟时间t=2，如图 4 所示为计算信号在不同尺度因子s下的MPE值。




 

二、参数优化方法

2.1 遗传算法（GA）

遗传算法的原理及MATLAB代码见地址：详解遗传算法（含MATLAB代码）

遗传算法的流程如图5所示。




2.2 粒子群优化算法（PSO）

粒子群优化算法的原理及MATLAB代码见地址：PSO-LSSVM算法及其MATLAB代码

粒子群优化算法的流程如图6所示。




2.3 多作用力粒子群优化算法（MFPSO）

多作用力粒子群优化（Multi  Force  Particle  Swarm  Optimization，MFPSO）算法是对PSO 算法的改进，是一种阶段性搜索算法。该算法通过增加粒子间的引力、斥力等作用力构造规则，形成前期、中期和后期三个搜索阶段，使算法的搜索能力与收敛速度得到提高。

三、多尺度排列熵参数优化

3.1 适应度函数的确定

为分析一组数据的总体趋势，通过求其均值，可以观察数据的集中趋势。但仅凭均值并不能够完全表征一组数据的总体概况，此时可以求取数据的偏度。偏度绝对值越大，表明均值的效能越有问题，偏度绝对值越小，则均值越可信赖。为此，本文选用多尺度排列熵偏度的平方函数作为目标函数，求其最小值。

偏度表征的是概率密度为非正态分布的随机序列偏离正态分布的程度，是统计数据分布非对称程度的数字特征。其中，偏度为零，表示对称分布；偏度大于零，表示不对称部分的分布更趋向正值；偏度小于零，表示不对称部分的分布更趋向负值。

将时间序列所有尺度下的排列熵组成序列，通过式（3-1）计算其偏度Ske：



其中， 为序列 的均值；为 序列的标准差；为求序列的期望。

目标函数为：



3.2 参数优化过程

多尺度排列熵的参数优化流程如图8所示，具体过程如下： 

（1）载入原始信号，设置各个优化算法的参数，初始化多尺度排列熵算法的参数；

（2）由式(3-17)及式(3-18)求适应度函数，分别利用GA、PSO和MFPSO对 MPE 的参数进行优化，得到 3 组优化参数；

（3）对 3 组优化参数进行对比分析，进而确定 MPE 的最优参数。




四、MATLAB源代码

遗传算法(GA)、粒子群优化算法(PSO)对多尺度排列熵算法(MPE)的参数进行寻优，得到最优参数，代码地址如下：参数优化多尺度排列熵

参考文献

[1]张运东. 基于 FVMD 多尺度排列熵和 GK 模糊聚类的故障诊断方法[D]. 秦皇岛：燕山大学, 32-45.

[2]陈东宁, 张瑞星, 姚成玉, 等. 求解液压阀块加工车间调度的多作用力微粒群算法[J]. 中国机械工程, 2015, 26(3): 369-378.

什么是超参数
所谓超参数，就是机器学习模型里面的框架参数，比如聚类方法里面类的个数，或者话题模型里面话题的个数等等，都称为超参数。它们跟训练过程中学习的参数(权重)是不一样的，通常是手工设定，不断试错调整，或者对一系列穷举出来的参数组合一通枚举(叫做网格搜索)。深度学习和神经网络模型，有很多这样的参数需要学习，这就是为什么过去这么多年从业者弃之不顾的原因。以前给人的印象，深度学习就是“黑魔法”。时至今日，非参数学习研究正在帮助深度学习更加自动的优化模型参数选择，当然有经验的专家仍然是必须的。
超参数调试处理
在机器学习领域，超参数比较少的情况下，我们之前利用设置网格点的方式来调试超参数；
但在深度学习领域，超参数较多的情况下，不是设置规则的网格点，而是随机选择点进行调试。这样做是因为在我们处理问题的时候，是无法知道哪个超参数是更重要的，所以随机的方式去测试超参数点的性能，更为合理，这样可以探究更超参数的潜在价值。
如果在某一区域找到一个效果好的点，将关注点放到点附近的小区域内继续寻找。
为超参数选择合适的范围
Scale均匀随机
在超参数选择的时候，一些超参数是在一个范围内进行均匀随机取值，如隐藏层神经元结点的个数、隐藏层的层数等。但是有一些超参数的选择做均匀随机取值是不合适的，这里需要按照一定的比例在不同的小范围内进行均匀随机取值，以学习率α的选择为例，在0.001,…,1范围内进行选择：
如上图所示，如果在 0.001,…,1 的范围内进行进行均匀随机取值，则有90%的概率 选择范围在 0.1∼1 之间，而只有10%的概率才能选择到0.001∼0.1之间，显然是不合理的。
所以在选择的时候，在不同比例范围内进行均匀随机取值，如0.001∼0.001、0.001∼0.01、0.01∼0.1、0.1∼1 范围内选择。
超参数调试实践–Pandas vs. Caviar
在超参数调试的实际操作中，我们需要根据我们现有的计算资源来决定以什么样的方式去调试超参数，进而对模型进行改进。下面是不同情况下的两种方式：
在计算资源有限的情况下，使用第一种，仅调试一个模型，每天不断优化；
在计算资源充足的情况下，使用第二种，同时并行调试多个模型，选取其中最好的模型。
本系列博客系人工智能社区(www.studyai.com)推出的视频课程<>的教案，均为授课老师 Antares博士 原创。我们允许进行全文链接式转载，但必须注明出处与原始链接。
DeepMind提出新型超参数最优化方法：性能超越手动调参和贝叶斯优化
《Population Based Training of Neural Networks》
参考文献：

系统参数优化

系统参数优化说明
默认的Linux内核参数考虑的是最通用场景，不符合用于支持高并发访问的Web服务器的定义，根据业务特点来进 行调整，当Nginx作为静态web内容服务器、反向代理或者提供压缩服务器的服务器时，内核参数的调整都是不同 的，此处针对最通用的、使Nginx支持更多并发请求的TCP网络参数做简单的配置,修改/etc/sysctl.conf来更 改内核参数。
系统参数优化实例


net.ipv4.ip_nonlocal_bind = 1

#允许非本地IP地址socket监听


net.ipv4.ip_forward = 1

#开启IPv4转发


net.ipv4.tcp_timestamps = 0

#是否开启数据包时间戳


net.ipv4.tcp_tw_reuse = 0

#端口复用


net.ipv4.tcp_tw_recycle = 0

#快速回收TIME_WAIT状态，用于大量TIME_OUT场景


fs.file-max = 1000000

#表示单个进程较大可以打开的句柄数


net.ipv4.tcp_tw_reuse = 1

#参数设置为 1 ，表示允许将TIME_WAIT状态的socket重新用于新的TCP链接，这对于服务器来说意义重大，因 为总有大量TIME_WAIT状态的链接存在


net.ipv4.tcp_keepalive_time = 600

#当keepalive启动时，TCP发送keepalive消息的频度；默认是2小时，将其设置为10分钟，可更快的清理无效链接


net.ipv4.tcp_fin_timeout = 30

#当服务器主动关闭链接时，socket保持在FIN_WAIT_2状态的较大时间


net.ipv4.tcp_max_tw_buckets = 5000

#表示操作系统允许TIME_WAIT套接字数量的较大值，如超过此值，TIME_WAIT套接字将立刻被清除并打印警告信 息,默认为8000，过多的TIME_WAIT套接字会使Web服务器变慢


net.ipv4.ip_local_port_range = 1024 65000

#定义UDP和TCP链接的本地端口的取值范围


net.ipv4.tcp_rmem = 10240 87380 12582912

#定义了TCP接受socket请求缓存的内存最小值、默认值、较大值


net.ipv4.tcp_wmem = 10240 87380 12582912

#定义TCP发送缓存的最小值、默认值、较大值


net.core.netdev_max_backlog = 8096

#当网卡接收数据包的速度大于内核处理速度时，会有一个列队保存这些数据包。这个参数表示该列队的较大值


net.core.rmem_default = 6291456

#表示内核套接字接受缓存区默认大小


net.core.wmem_default = 6291456

#表示内核套接字发送缓存区默认大小


net.core.rmem_max = 12582912

#表示内核套接字接受缓存区较大大小


net.core.wmem_max = 12582912

#表示内核套接字发送缓存区较大大小

注意：以上的四个参数，需要根据业务逻辑和实际的硬件成本来综合考虑


net.ipv4.tcp_syncookies = 1

#与性能无关。用于解决TCP的SYN攻击


net.ipv4.tcp_max_syn_backlog = 8192

#这个参数表示TCP三次握手建立阶段接受SYN请求列队的较大长度，默认1024，将其设置的大一些可使出现 Nginx繁忙来不及accept新连接时，Linux不至于丢失客户端发起的链接请求


net.ipv4.tcp_tw_recycle = 1

#这个参数用于设置启用timewait快速回收


net.core.somaxconn=262114

#选项默认值是128，这个参数用于调节系统同时发起的TCP连接数，在高并发的请求中，默认的值可能会导致链接 超时或者重传，因此需要结合高并发请求数来调节此值。


net.ipv4.tcp_max_orphans=262114

#选项用于设定系统中最多有多少个TCP套接字不被关联到任何一个用户文件句柄上。如果超过这个数字，孤立链接 将立即被复位并输出警告信息。这个限制指示为了防止简单的DOS攻击，不用过分依靠这个限制甚至认为的减小这 个值，更多的情况是增加这个值

之前为了实现利用遗传算法，进行多进程策略的优化，学习研究了python的多进程库Multiprocessing。以前感觉真是黑科技，学习后发现，还是python优点，简单好用，对于一般应用还是很好理解。
首先，由于GIL(全局解释锁)的问题，全局对象只能一个进程调用，python多线程并不能充分利用多核处理器，比如有时候用pandas跑大型数据分析，发现只有一核在累死累活。如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。multiprocessing可以给每个进程赋予单独的Python解释器，这样就规避了全局解释锁所带来的问题。可以理解为多核CPU分配好一个工作任务，这个工作任务包括工作方法和工作内容。
其实python多线程很简单，相对于其他语言来说。其实简单就是针对需要多线程的方法func(a)，a是参数。相当于工作内容；使用
Multiprocessing.
Process(target = func, args =(a,)),创建一个Prcoess对象，也就是工作任务，再启动这个对象，这样一个多进程任务就完成了。等CPU分配一个独立核去干活，func(a)就开动了。这里唯一要注意args是默认输入元祖参数。
P = Multiprocessing.Process(target = func, args =(a,))
P.start()
Multiprocessing提供了更简洁的pool做为进程池，其实叫任务池更为恰当。把需要干的工作任务打包好，放在这个池子里面，这样空闲下来的核心就捡pool的任务干活。
常见的pool的使用如下，其中prcesses = 4 是定义任务池大小，不一定要小于或者等于cpu核心数量，可以大于cpu核心数量，不过这样就有几个任务空挂着还占用内存。
然后使用pool方法apply_async(task, args=(x,))，把打包好的任务插入池中。
apply_asyncs是异步的带返回值。如果用apply也可以正常，但是会没有返回值，此处不仔细研究了。
之后close()是把这个任务池关闭，不再接受新的任务；但是还有一些已有任务在跑，所以用pool.join()，吊着主程序，直到所有任务完成才进入下一步。
if __name__ == '__main__':
Multiprocessing.pool = Pool(processes=4)
for x in range(10):
pool.apply_async(task, args=(x,))
pool.close()
pool.join()
下面看看VNPY多进程优化方法。其实很好理解了，runParallelOptimization是类BacktestingEngine的一个方法。
传入参数strategyClass就是这个策略类，setting是要优化参数范围，后面通过optimizationSetting.generateSetting()生成策略参数队列，做为任务内容；optimizationSetting.optimizeTarget是后面返回值。至于回测品种，回测时间段，交易费用什么，在
BacktestingEngine创建时候维护了。
然后创建任务池pool，大小刚好是cpu核数，这个也是比较稳妥设置。
之后做一个l队列来放返回值。
然后打包策略类，回测参数，策略参数做为任务内容，和任务方法optimize一起组合为一个工作任务。然后插入任务池给cpu核心去跑。这个时候在系统监视器可以看到于核心数相同的python虚拟环境运作。
然后就是对返回值排序。后面详细说说。
df =  engine.runParallelOptimization(AtrRsiStrategy, setting)
def runParallelOptimization(self, strategyClass, optimizationSetting):
"""并行优化参数"""
# 获取优化设置
settingList = optimizationSetting.generateSetting()
targetName = optimizationSetting.optimizeTarget
# 检查参数设置问题
if not settingList or not targetName:
self.output(u'优化设置有问题，请检查')
# 多进程优化，启动一个对应CPU核心数量的进程池
pool = multiprocessing.Pool(multiprocessing.cpu_count())
l = []
for setting in settingList:
l.append(pool.apply_async(optimize, (strategyClass, setting,
targetName, self.mode,
self.startDate, self.initDays, self.endDate,
self.slippage, self.rate, self.size, self.priceTick,
self.dbName, self.symbol)))
pool.close()
pool.join()
# 显示结果
resultList = [res.get() for res in l]
resultList.sort(reverse=True, key=lambda result:result[1])
return resultList
像现在双核四线程就有四个python环境在跑任务。
这里会发现是用静态方法optimize，如果直接调用
BacktestingEngine的回测方法更简洁，为什么没有呢，这个是python2.7的Multiprocessing的一个局限，只能打包静态方法做为工作方法，如果打包类中的方法，会提示错误。
cPickle.PicklingError: Can't pickle : attribute lookup
builtin
.instanceme
如果VNPY2.0基于python3.6版本，应该就会更简化一些。
下面看看
静态方法
optimize，其实没什么好说，就是新建一个回测引擎BacktestingEngine对象，按照参数跑一遍回测，返回一个元祖，包含了这次回测的参数，针对回测目标的值，和一个包含回测结果的字典，这个字典包括什么年化收入，sharpe等一堆回测结果。
然后所有的回测结果元祖组成一个回测结果队列，这个结果队列按照targetValue反向排序，最大放在第一位。
因为太多了，一般我都是输出到excel里面，之前说过怎么实现。
#----------------------------------------------------------------------
def optimize(strategyClass, setting, targetName,
mode, startDate, initDays, endDate,
slippage, rate, size, priceTick,
dbName, symbol):
"""多进程优化时跑在每个进程中运行的函数"""
engine = BacktestingEngine()
engine.setBacktestingMode(mode)
engine.setStartDate(startDate, initDays)
engine.setEndDate(endDate)
engine.setSlippage(slippage)
engine.setRate(rate)
engine.setSize(size)
engine.setPriceTick(priceTick)
engine.setDatabase(dbName, symbol)
engine.initStrategy(strategyClass, setting)
engine.runBacktesting()
engine.calculateDailyResult()
d, result = engine.calculateDailyStatistics()
try:
targetValue = result[targetName]
except KeyError:
targetValue = 0
return (str(setting), targetValue, result)
其实python的多进程库Multiprocessing不算复杂，但是用在回测上效果很好；现在有了遗传算法，进行策略优化更加方便了。