如何降低计算成本

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。

[当您看到某些值可能很早就不再使用时，其他超参数也可能会变窄，尽管贝叶斯优化可以部分地解决这个问题。