如何降低计算成本

Question

使用GPyOpt对基于Tensorflow的LSTM模型的参数进行了优化计算。然而，与典型的过程不同，参数的验证是通过最小化方差而不是偏差来实现的。因此，需要迭代使用参数集运行的LSTM模型。事实上，我的脚本工作得很好，没有任何错误，但返回最佳参数需要花费太多时间。我试着找出任何方法来提高处理速度，但无法。

我认为其他模块，例如GridSearch或RandomizedSearch可能比GpyOp更快，但它们使用贝叶斯优化来获得参数。

有没有办法降低这个操作的计算成本？

我的电脑：MackBook, 2.3 GHz Intel Core i5

我的脚本：

import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'
os.environ['PYTHONHASHSEED']='0'
os.environ['OMP_NUM_THREADS']='4'
os.environ['KMP_BLOCKTIME']='30'
os.environ['KMP_SETTINGS']='1'
os.environ['KMP_AFFINITY']='granularity=fine,verbose,compact,1,0'

import tensorflow as tf
import numpy as np
import GPyOpt

import random

NUM_PARALLEL_EXEC_UNITS=4
config=tf.ConfigProto(intra_op_parallelism_threads=NUM_PARALLEL_EXEC_UNITS,
                      inter_op_parallelism_threads=2,
                      allow_soft_placement=True,
                  device_count={'CPU':NUM_PARALLEL_EXEC_UNITS})

def parameter_opt(df_x,df_y):

    x_set_list=[]
    y_set_list=[]
    for i in range(10): #create 10 data sets for calculating variance
        t=random.randint(1,2300)
        x_set_=df_x[t:t+10,:,:] #x_set_.shape is (10,7,5)
        y_set_=df_y[t:t+10,:]
        x_set_list.append(x_set_)
        y_set_list.append(y_set_)

    pred_x=df_x[-10:,:,:]


    bounds=[{'name':'hidden_layer','type':'discrete','domain':(10,50,100,300,500)},
            {'name':'learn_rate','type':'discrete','domain':(0.1,0.01,0.001,0.0001)},
            {'name':'forget','type':'continuous','domain':(0.1,1.0)},
            {'name':'std','type':'continuous','domain':(0.01,1.0)},
            {'name':'epo','type':'discrete','domain':(50,100,200,400)},
            {'name':'cell_drop_','type':'discrete','domain':(0,1)},
            {'name':'output_keep','type':'continuous','domain':(0.1,1.0)}]

    def f(x):
        tf.reset_default_graph()

        def LSTMmse(hidden_layer,learn_rate,forget,std,epo,cell_drop_, output_keep):
            pred_array=np.empty((10,0))
            for x_set,y_set in zip(x_set_list,y_set_list):
                tf.reset_default_graph()
                .......
                #LSTM model
                #generate prediction_list consisting of 10 predictionvalue 
                .........
            variance_list=np.var(prediction_list,axis=1)
            variance_ave=sum(var_list)/len(var_list)
            return variance_ave

        for x_ in x:
            vari=LSTMmse(hidden_layer=int(x_[0]),
                        learn_rate=np.float32(x_[1]),
                        forget=np.float32(x_[2]),
                        std=np.float32(x_[3]),
                        epo=int(x_[4]),
                        cell_drop_=bool(x_[5]),
                        output_keep=np.float32(x_[6]))
         return vari

    myBopt=GPyOpt.methods.BayesianOptimization(f=f,domain=bounds,acquisition_type='MPI')

    myBopt.run_optimization(max_iter=10)
    opt=myBopt.x_opt
    opt=[int(opt[0]),opt[1],opt[2],opt[3],int(opt[4]),opt[5],opt[6]]

    key=['hidden_layer','learn_rate','forget','std','epo','cell_drop','output_keep']
    value=opt
    para_dict=dict(zip(key,value))
    return para_dict

parameter_opt=parameter_opt(df_x,df_y)
print(parameter_opt)  # spending too much time

Answer 1

有几件事你可以试一试：

GRU而不是LSTM

这种单元类型少了一个栅极，因此计算效率更高。

此外，它们具有更少的超参数，因此可能的搜索空间更小。

没有什么结论，但奇闻轶事，它们的表现与LSTM相当，至少对于中等长度的序列。

使用CUDA

如果可能，请使用支持CUDA的设备来训练您的网络。特别是，对于tensorflow使用CuDNNGRU版本(对于tf2.x请参见this，也有针对1.x的选项)。

缩小你的搜索空间

搜索的超参数越少，执行速度就越快。learning_rate通常是非常重要的正确的。

由Leslie N. Smith在Cyclical Learning Rates for Training Neural Networks提出并由fastai社区推广的近似最佳学习率的技巧是众所周知的。

基本思想-将学习率设置得非常低(例如1e-7)，并在每批n中按指数递增，直到达到阈值(最高的lr，通常在1.0左右)。

监测train或validation损失，你会发现它可能会以某种学习速度飙升。你选择这一点，并将你的近似最优学习10设置得比这更低。

你可以在here上读到它。

其他超参数也可以缩小范围，当您看到一些值可能在早期是不允许的，尽管贝叶斯优化部分地解决了这一问题。