Указание автоэнкодера seq2seq. Что делает RepeatVector? И как влияет пакетное обучение на прогнозирование результатов? - PullRequest
Новая
       45

Указание автоэнкодера seq2seq. Что делает RepeatVector? И как влияет пакетное обучение на прогнозирование результатов?

2 голосов
/ 07 октября 2019

Я создаю базовый авто-кодер seq2seq, но я не уверен, правильно ли я это делаю. 

model = Sequential()
# Encoder       
model.add(LSTM(32, activation='relu', input_shape =(timesteps, n_features ), return_sequences=True))
model.add(LSTM(16, activation='relu', return_sequences=False))
model.add(RepeatVector(timesteps))
# Decoder
model.add(LSTM(16, activation='relu', return_sequences=True))
model.add(LSTM(32, activation='relu', return_sequences=True))
model.add(TimeDistributed(Dense(n_features)))'''

Затем модель подгоняется с использованием параметра размера партии 

model.fit(data, data,       
          epochs=30, 
          batch_size = 32)

Модель компилируется с функцией потери mse и, кажется, учится.

Чтобы получить выходные данные датчика для тестовых данных, я использую функцию K: 

get_encoder_output = K.function([model.layers[0].input],
                                  [model.layers[1].output])

encoder_output = get_encoder_output([test_data])[0]

Мой первый вопрос - правильно ли указана модель. В частности, нужен ли слой RepeatVector. Я не уверен, что он делает. Что если я опущу его и укажу предыдущий слой с помощью return_sequences = True?

Мой второй вопрос: нужно ли мне рассказать get_encoder_output о batch_size, используемом при обучении?

Спасибо зазаранее за любую помощь по любому вопросу.

Ответы [ 2 ]

2 голосов
/ 10 октября 2019

Это может оказаться полезным для вас:

В качестве проблемы с игрушкой я создал модель seq2seq для предсказания продолжения различных синусоидальных волн.

Это была модель: 

def create_seq2seq():
    features_num=5 
    latent_dim=40

    ##
    encoder_inputs = Input(shape=(None, features_num))
    encoded = LSTM(latent_dim, return_state=False ,return_sequences=True)(encoder_inputs)
    encoded = LSTM(latent_dim, return_state=False ,return_sequences=True)(encoded)
    encoded = LSTM(latent_dim, return_state=False ,return_sequences=True)(encoded)
    encoded = LSTM(latent_dim, return_state=True)(encoded)

    encoder = Model (input=encoder_inputs, output=encoded)
    ##

    encoder_outputs, state_h, state_c = encoder(encoder_inputs)
    encoder_states = [state_h, state_c]

    decoder_inputs=Input(shape=(1, features_num))
    decoder_lstm_1 = LSTM(latent_dim, return_sequences=True, return_state=True)
    decoder_lstm_2 = LSTM(latent_dim, return_sequences=True, return_state=True)
    decoder_lstm_3 = LSTM(latent_dim, return_sequences=True, return_state=True)
    decoder_lstm_4 = LSTM(latent_dim, return_sequences=True, return_state=True)

    decoder_dense = Dense(features_num)

    all_outputs = []
    inputs = decoder_inputs


    states_1=encoder_states
    # Placeholder values:
    states_2=states_1; states_3=states_1; states_4=states_1
    ###

    for _ in range(1):
        # Run the decoder on the first timestep
        outputs_1, state_h_1, state_c_1 = decoder_lstm_1(inputs, initial_state=states_1)
        outputs_2, state_h_2, state_c_2 = decoder_lstm_2(outputs_1)
        outputs_3, state_h_3, state_c_3 = decoder_lstm_3(outputs_2)
        outputs_4, state_h_4, state_c_4 = decoder_lstm_4(outputs_3)

        # Store the current prediction (we will concatenate all predictions later)
        outputs = decoder_dense(outputs_4)
        all_outputs.append(outputs)
        # Reinject the outputs as inputs for the next loop iteration
        # as well as update the states
        inputs = outputs
        states_1 = [state_h_1, state_c_1]
        states_2 = [state_h_2, state_c_2]
        states_3 = [state_h_3, state_c_3]
        states_4 = [state_h_4, state_c_4]


    for _ in range(149):
        # Run the decoder on each timestep
        outputs_1, state_h_1, state_c_1 = decoder_lstm_1(inputs, initial_state=states_1)
        outputs_2, state_h_2, state_c_2 = decoder_lstm_2(outputs_1, initial_state=states_2)
        outputs_3, state_h_3, state_c_3 = decoder_lstm_3(outputs_2, initial_state=states_3)
        outputs_4, state_h_4, state_c_4 = decoder_lstm_4(outputs_3, initial_state=states_4)

        # Store the current prediction (we will concatenate all predictions later)
        outputs = decoder_dense(outputs_4)
        all_outputs.append(outputs)
        # Reinject the outputs as inputs for the next loop iteration
        # as well as update the states
        inputs = outputs
        states_1 = [state_h_1, state_c_1]
        states_2 = [state_h_2, state_c_2]
        states_3 = [state_h_3, state_c_3]
        states_4 = [state_h_4, state_c_4]


    # Concatenate all predictions
    decoder_outputs = Lambda(lambda x: K.concatenate(x, axis=1))(all_outputs)   

    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

    #model = load_model('pre_model.h5')


    print(model.summary()
    return (model)
1 голос
/ 08 октября 2019

Лучший способ, на мой взгляд, реализовать LSTM seq2seq в Керасе, это использовать 2 модели LSTM и заставить первую перенести свои состояния во вторую.

Ваш последний слой LSTM вкодировщику потребуется

return_state=True ,return_sequences=False, поэтому он передаст свои h и c.

. Затем вам нужно будет установить декодер LSTM, который будет принимать их, как initial_state,

Для ввода декодера вам, скорее всего, понадобится токен «начала последовательности» в качестве входа первого временного шага, а затем использовать выход декодера шага времени nth в качестве входа декодера в(n+1)th шаг по времени.

После того, как вы освоите это, взгляните на Принудительное принуждение.

...