笔记（13）中介绍了在策略中对单个参数进行优化的实现方法，本文将介绍对策略中的多个参数进行优化的方案。
 
以笔记（14）中介绍的均线交叉策略为例，实现不同长期、短期均线参数组合的优化测试，回测股票为000001平安银行，回测周期为2018年1月1日至2020年4月15日。
 
方案1——使用多个list
 在向cerebro中添加策略时，使用list来定义长期、短期均线的取值：
 
strats = cerebro.optstrategy(
        SmaCross,
        pfast = [5, 10, 15],
        pslow = [20, 30, 60])
 
在策略类中的init函数中，使用相应的参数：
 
    params = dict(
        pfast=5,  # 短期均线周期
        pslow=10   # 长期均线周期
    )
    def __init__(self):
        sma1 = bt.ind.SMA(period=self.p.pfast)  # 短期均线
        sma2 = bt.ind.SMA(period=self.p.pslow)  # 长期均线
        self.crossover = bt.ind.CrossOver(sma1, sma2)  # 交叉信号
 
在上面的代码中，短期均线会依次取5、10、15三个值，长期均线会依次取20、30、60三个值，这样就会形成3*3=9种组合，执行程序后输出如下：
 
(Fast Period   5, Slow Period  20) Ending Value 101321.23
(Fast Period   5, Slow Period  30) Ending Value 109934.13
(Fast Period   5, Slow Period  60) Ending Value 116776.70
(Fast Period  10, Slow Period  20) Ending Value 107225.67
(Fast Period  10, Slow Period  30) Ending Value 107899.79
(Fast Period  10, Slow Period  60) Ending Value 110485.50
(Fast Period  15, Slow Period  20) Ending Value 95051.12
(Fast Period  15, Slow Period  30) Ending Value 104954.36
(Fast Period  15, Slow Period  60) Ending Value 106075.20
 
方案2——使用tuple（元组）的list
 在向cerebro中添加策略时，将长期、短期均线的取值组成一个tuple，将所有的待测取值构建成tuple的list：
 
strats = cerebro.optstrategy(
        SmaCross,
        period = [(5, 10), (20, 100), (2, 10)])
 
在策略类中的init函数中，使用相应的参数：
 
    params = dict(
        period = (5, 10), # 元组，(短期均线周期,长期均线周期)
    )
    def __init__(self):
        sma1 = bt.ind.SMA(period=self.p.period[0])  # 短期均线
        sma2 = bt.ind.SMA(period=self.p.period[1])  # 长期均线
        self.crossover = bt.ind.CrossOver(sma1, sma2)  # 交叉信号
 
在上面的代码中，短期均线和长期均线会形成了3个组合供测试优化，执行程序后输出如下：
 
(Fast Period   5, Slow Period  10) Ending Value 92377.83
(Fast Period  20, Slow Period 100) Ending Value 107292.25
(Fast Period   2, Slow Period  10) Ending Value 90157.66
 
方案1和方案2在使用时稍有区别：
 
方案1对所有参数的所有取值形成的所有组合都会进行回测
方案2仅针对给定的参数组合进行回测
 
策略多参数优化代码（方案2）：
 
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import datetime  # 用于datetime对象操作
import os.path  # 用于管理路径
import sys  # 用于在argvTo[0]中找到脚本名称
import backtrader as bt # 引入backtrader框架

# 创建策略
class SmaCross(bt.Strategy):
    # 可配置策略参数
    params = dict(
        period = (5, 10), # 元组，(短期均线周期,长期均线周期)
    )
    def __init__(self):
        sma1 = bt.ind.SMA(period=self.p.period[0])  # 短期均线
        sma2 = bt.ind.SMA(period=self.p.period[1])  # 长期均线
        self.crossover = bt.ind.CrossOver(sma1, sma2)  # 交叉信号
    def next(self):
        if not self.position:  # 不在场内，则可以买入
            if self.crossover > 0:  # 如果金叉
                self.buy()  # 买入
        elif self.crossover < 0:  # 在场内，且死叉
            self.close()  # 卖出
    def stop(self):
        print('(Fast Period %3d, Slow Period %3d) Ending Value %.2f' %
         (self.params.period[0], self.params.period[1], self.broker.getvalue()))
cerebro = bt.Cerebro()  # 创建cerebro
# 先找到脚本的位置，然后根据脚本与数据的相对路径关系找到数据位置
# 这样脚本从任意地方被调用，都可以正确地访问到数据
modpath = os.path.dirname(os.path.abspath(sys.argv[0]))
datapath = os.path.join(modpath, '../TQDat/day/stk/000001.csv')
# 创建价格数据
data = bt.feeds.GenericCSVData(
        dataname = datapath,
        fromdate = datetime.datetime(2018, 1, 1),
        todate = datetime.datetime(2020, 4, 15),
        nullvalue = 0.0,
        dtformat = ('%Y-%m-%d'),
        datetime = 0,
        open = 1,
        high = 2,
        low = 3,
        close = 4,
        volume = 5,
        openinterest = -1
        )
# 在Cerebro中添加价格数据
cerebro.adddata(data)
# 设置启动资金
cerebro.broker.setcash(100000.0)
# 设置交易单位大小
cerebro.addsizer(bt.sizers.FixedSize, stake = 5000)
# 设置佣金为千分之一
cerebro.broker.setcommission(commission=0.001)
# 添加策略
strats = cerebro.optstrategy(
        SmaCross,
        period = [(5, 10), (20, 100), (2, 10)])
cerebro.run(maxcpus = 1)  # 遍历所有数据
 
为了便于相互交流学习，新建了微信群，感兴趣的读者请加微信。
 

MATLAB天牛须搜索算法求解数据拟合和多参数优化问题代码实例
 

 
 
MATLAB天牛须搜索算法求解数据拟合和多参数优化问题代码实例

 

 
 
天牛须搜索（BAS）算法
 

 
 
数据拟合和多参数优化问题实例：
 已知一组观测数据（x, y）满足一定的函数关系y=f(x)，求函数关系f中的未知参数。
 具体到该问题为：
 已知一组观测数据（x, y），如图1所示。x和y大致满足如下函数关系：
 试求 的值？ 使得x和y的拟合程度达到最佳！
 
 
图1 需要拟合的观测数据
 
编程求解结果：
 
 
待求解参数最优解分别为
 a= 0.3476
 b= 2.5101

       参数是指算法中的未知数，有的需要人为指定，比如神经网络算法中的学习效率，有的是从数据中拟合而来，比如线性回归中的系数，如此等等。在使用选定算法进行建模时，设定或得到的参数很可能不是最优或接近最优的，这时需要对参数进行优化以得到更优的预测模型。常用的参数优化方法主要包括交叉验证、网格搜索、遗传算法、粒子群优化、模拟退火，本节介绍遗传算法。
 
      遗传算法实质：选定一批最佳参数，使得目标函数最优。
 
1.基本概念
 
        遗传算法是模拟自然界遗传选择与淘汰的生物进化计算模型。达尔文的自然选择学说认为，遗传和变异是决定生物进化的内在因素。遗传是指父代与子代之间，在性状上的相似现象，而变异是指父代与子代之间以及子代的个体之间，在性状上或多或少地存在的差异现象，变异能够改变生物的性状以适应新的环境变化。而生存斗争是生物进化的外在因素，由于弱肉强食的生存斗争不断地进行，其结果是适者生存，具有适应性变异的个体被保留下来，不具有适应性变异的个体被淘汰。更进一步，孟德尔提出了遗传学的两个基本规律：分离律和自由组合律，认为生物是通过基因突变与基因的不同组合和自然选择的长期作用而进化的。
 
       由于生物进化与某些问题的最优求解过程存在共通性，即都是在产生或寻找最优的个体(或者问题的解)，这就产生了基于自然选择、基因重组、基因突变等遗传行为来模拟生物进化机制的算法，通常叫作遗传算法，它最终发展成为一种随机全局搜索和优化的算法。
 
       遗传算法研究的对象是种群，即很多个体的集合，对应于求解的问题，这里的个体代表一个解，种群代表这些解的集合，当然，开始的时候，也许所有的解不是最优的，经过将这些解进行编码、选择、交叉、变异之后，逐代进化，从子代中可以找到求解问题的全局最优解。
 
编码：将表现型的解转化为基因型，便于进行遗传操作；
解码：即是从基因型转化为表现型，以直观判断个体的表现以，从而决定是否选择进入下一代或直接得到最优解。
选择的标准：优化准则。
交叉：也就是基因重组，即两个个体，互相交换 因型的对应片段。
变异：指的是基因突变，是指个体基因型中某个基因的改变。
      种群的每代个体经过了这几个关键的步骤之后，种群得以进化，在最终的子代中找到问题的最优解。这就是使用遗传算法求解最优化问题的大致过程。
 
2、名词概念
 
      染色体（个体）：在参数寻优问题中一个染色体代表一个参数，染色体的十进制数值，用于获取待寻优参数实际输入到模型中的值。
 
      基因：每一个染色体都对应多个基因，基因是二进制数，基因的取值长度是染色体的长度。遗传算法的交叉、变异操作都是对染色体的基因进行的。
 
      种群：初始化的染色体可能的取值数
 
      适应度函数：表征每一组染色体（每一组参数）对应的模型评价指标（本博文的python实例中，采用3-flod 交叉检验的平均值作为适应度函数值）。
 
      假设对于两个参数的寻优，我们设定染色体长度为20，种群数为200，就是说初始化两个染色体，每个染色体初始化200个可能的值，每一个染色体的十进制数值用20位二进制数表示。、
 
3. 遗传算法实现过程
 
第一步：编码。变量x是遗传算法的表现型形式，从表现型到基因型的映射称为编码，通常采用二进制编码形式，串的长度取决于求解的精度。
 
染色体长度：如参数batch取值范围为[10，100]，区间长度为90，将其分成90份。因为：
                                                                   
 
                     所以二进制串的长度是7，即染色体长度是7。
 
解码：二进制对应的十进制数
                                             
 
（1）首先将二进制转为十进制：比如一个二进制为10101，转化为十进制就是（2）把21放到上面的解码公式就得到了最终的batch：min=10，max=100
 
第二步：产生父代个体，构建初始种群。
 
第三步：选择个体。根据适应度函数选择再生个体，被选出的概率正比于染色体的适应性，适应性分数愈高，被选中的可能性也就愈大。常用的方法就是采用所谓的轮盘赌选择法。
 
第四部：交叉。
 
第五步：变异。
 
即：
 
       第一步：（产生初始种群：即优化参数的候选者）根据种群规模，随机产生初始种群，每个个体表示染色体的基因型，如LSTM超参数batch_size、epochs等优化，初始种群为batch_size、epochs的候选值。
        第二步：（计算适应度：即目标函数）计算每个个体的适应度，并判断是否满足优化准则，若满足，则输出最佳个体及其代表的最优解，并结束算法；若不满足，则转入下一步。适应度，即因变量f，如LSTM的loss。
        第三步：（选择）依据适应度选择再生个体，适应度高的个体被选中的概率高，反之，适应度低的个体被选中的概率低，甚至可能被淘汰。
        第四步：（交叉）根据一定的交叉概率和交叉方法生成子代个体。
        第五步：（变异）根据一定的变异概率和变异方法，生成子代个体。
        第六步：（循环计算适应度）由交叉和变异产生新一代种群，返回到第二步。
 
 遗传算法中的优化准则，一般根据问题的不同有不同的确定方式。通常采取如下之一作为判断条件:
 
种群中个体的最大适应度超过了设定值。(随着代数的增大，最大适应度向变大的方向移动；适应度值越大，表示解的质量越好)
种群中个体的平均适应度超过了设定值。
世代数超过了设定值。
种群中个体的最大适应度除以平均适应度超过了设定值。 
4、遗传算法单参数/多参数寻优
 
       多参数寻优和单一参数寻优的基本思路是相同的，不过在种群初始化时，每次需要初始化m个染色体，并且在选择、交叉、变异操作时，m个染色体是分别进行的。
 
      步骤一：种群、染色体、基因初始化。
       步骤二：计算种群中每一组染色体对应的适应度函数值。
       步骤三：对种群中的染色体进行选择、交叉、变异操作，产生新的种群。
       步骤四：判断是否满足终止条件？如果不满足，跳转到步骤二；如果满足，输出最优参数。
       步骤五：结束。
 
5. 代码实现 
 
5.1 python实现
 
     参考：遗传算法(GA)的新手入门必备，python3案例
 
                python遗传算法(详解)
 
                遗传算法多参数寻优
 
4.2 R实现
 
      R语言预测实战：6.3.5

优化问题:给定目标函数f(x)，我们需要找到一组参数x，使得f(x)的值最小
 
1.Vanilla update
 
tensorflow实现
 
optimizer = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate)
 
直接进行优化
 
train_op = optimizer.minimize(loss)
 
 
x += - learning_rate * dx
 
 
对于训练数据集，我们首先将其分成n个batch，每个batch包含m个样本。我们每次更新都利用一个batch的数据，而非整个训练集。即：
 
 
 
好处在于：
 
当训练数据太多时，利用整个数据集更新往往时间上不显示。batch的方法可以减少机器的压力，并且可以更快地收敛
 
当训练集有很多冗余时（类似的样本出现多次），batch方法收敛更快。以一个极端情况为例，若训练集前一半和后一半梯度相同。那么如果前一半作为一个batch，后一半作为另一个batch，那么在一次遍历训练集时，batch的方法向最优解前进两个step，而整体的方法只前进一个step
 

 
 
2.Momentum update动量更新
 
tensorflow实现
 
optimizer = tf.train.MomentumOptimizer(lr, 0.9)
 
直接进行优化
 
train_op = optimizer.minimize(loss)
 
 
v = mu * v - learning_rate * dx # integrate velocity
 
x += v # integrate position
 
SGD方法的一个缺点是，其更新方向完全依赖于当前的batch，因而其更新十分不稳定。解决这一问题的一个简单的做法便是引入momentum。
 
momentum即动量，它模拟的是物体运动时的惯性，即更新的时候在一定程度上保留之前更新的方向，同时利用当前batch的梯度微调最终的更新方向。这样一来，可以在一定程度上增加稳定性，从而学习地更快，并且还有一定摆脱局部最优的能力： 
 

 
 

 
 
其中一般的，v初始为0，mu是优化参数，一般初始化参数为0.9，当使用交叉验证的时候，参数mu一般设置成[0.5,0.9,0.95,0.99]，在开始训练的时候，梯度下降较快，可以设置mu为0.5，在一段时间后逐渐变慢了，mu可以设置为0.9、0.99。也正是因为有了“惯性”，这个比SGD会稳定一些。
 
 

 
 
3.Nesterov Momentum
 
x_ahead = x + mu * v 
 v = mu * v - learning_rate * dx_ahead
 x += v
 
 

 
 
这是Momentum update的改进版，之前我们采用v = mu * v - learning_rate * dx的方法计算增量，其中的dx还是当前的x，但是我们已经知道了，下一刻的惯性将会带我们去的位置，所以现在我们要用加了mu*v之后的x，来更新位置(在更新后的位置而不是在原点求解梯度)，下面的图很形象： 
 
 

 
 

 
 
4.Adagrad
 
tensorflow实现
 
 
optimizer = tf.train.AdagradientOptimizer(learning_rate=self.learning_rate)
 
直接进行优化
 
train_op = optimizer.minimize(loss)
 
 
cache += dx**2
 x += - learning_rate * dx / (np.sqrt(cache) + eps)
 
上面提到的方法对于所有参数都使用了同一个更新速率。但是同一个更新速率不一定适合所有参数。比如有的参数可能已经到了仅需要微调的阶段，但又有些参数由于对应样本少等原因，还需要较大幅度的调动。Adagrad就是针对这一问题提出的，自适应地为各个参数分配不同学习率的算法。
 

 
 
 
 
 

 其中
 gt
 
  同样是当前的梯度，连加和开根号都是元素级别的运算。
 eta
 是初始学习率，由于之后会自动调整学习率，所以初始值就没有之前的算法那样重要了。
 eps是一个平滑的过程，取值通常在（10^-4~10^-8 之间）
 

 其含义是，对于每个参数，随着其更新的总距离增多，其学习速率也随之变慢。
 
 

 Adagrad中chche累加的原因是在后期作为惩罚项，这样的话学习率越来越小，符合在最后接近收敛的时候，步长越来越小的要求。
 

  
 
前期gt较小的时候，chche累加 regularizer较大，能够放大梯度
 后期gt较大的时候，chche累加regularizer较小，能够约束梯度
 适合处理稀疏梯度
 
 
 
 

  
 
 
5.RMSprop
 
tensorflow实现
 
 
optimizer = tf.train.RMSPropOptimizer(0.001, 0.9)
 
直接进行优化
 
train_op = optimizer.minimize(loss)
 
 
cache= decay_rate*cache+ (1- decay_rate)* dx**2
 x+=- learning_rate* dx/ (np.sqrt(cache)+ eps)
 

 decay_rate是一个超参数，常用的值是[0.9,0.99,0.999]。其中x+=和Adagrad中是一样的，但是cache变量是不同的。
 

 因此，RMSProp仍然是基于梯度的大小来对每个权重的学习率进行修改，这同样效果不错。
 

 但是和Adagrad不同，其更新不会让学习率单调变小。
 
 

 
 
 
6.Adam
 
tensorflow函数：
 

  
 
 class tf.train.AdamOptimizer
 
 
 __init__(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam')
 
 
 
 
 
直接进行优化
 
 train_op = optimizer.minimize(loss)
 
 
 
m = beta1*m + (1-beta1)dx
 v = beta2*v + (1-beta2)
 v = beta2*v + (1-beta2)(dx**2)
 x += - learning_rate * m / (np.sqrt(v) + eps)
 
有点像RMSProp+momentum
 
 

 
 

 参考来自：
 

  
 
http://blog.csdn.net/bea_tree/article/details/51523733#411-vanilla-update
 
 
http://blog.csdn.net/luo123n/article/details/48239963