Как уменьшить вычислительные затраты

Question

Я использую GPyOpt для расчета оптимизированных параметров модели LSTM на основе Tensorflow. Однако, в отличие от типичного процесса, проверка параметров осуществляется путем минимизации отклонений, а не смещения. Следовательно, требуется выполнить итерацию модели LSTM, работающей с набором параметров. На самом деле, мой скрипт работает хорошо без каких-либо ошибок, но он занимает слишком много времени, чтобы вернуть оптимальные параметры. Я пытался найти какие-либо способы улучшить скорость обработки, но не смог.

Я думаю, что другие модули, например GridSearch или RandomizedSearch, возможно, быстрее, чем один из GpyOp, но они используют байесовскую оптимизацию для получения параметров.

Есть ли способ уменьшить вычислительные затраты этой операции?

Мой P C: 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 см. это , также есть опции для 1.x).

Сокращение пространства поиска

Чем меньше гиперпараметров для поиска, тем быстрее будет go. learning_rate, как правило, очень важно, чтобы получить право.

Существует довольно известный прием для аппроксимации оптимальной скорости обучения, предложенный Lesl ie Н. Смитом в Циклические курсы обучения для обучения нейронных сетей и популяризируется fastai сообществом.

Базовая c идея - вы устанавливаете очень низкую скорость обучения (например, 1e-7) и увеличиваете ее экспоненциально каждые n партии до достижения порога (максимальное значение lr, обычно около 1.0).

Отслеживание потерь train или validation, которое вы увидите, вероятно, резко возрастет при некоторой скорости обучения. Вы берете эту точку и устанавливаете ваше примерно оптимальное обучение на 10 ниже этого.

Вы можете прочитать об этом здесь .

Другие гиперпараметры также могут быть сужены, когда вы видите, что некоторые значения, вероятно, отсутствуют - go на ранней стадии, хотя байесовская оптимизация позаботится об этом частично.