machine-learning - sentiment - recurrent neural network time series prediction python

Muchos a uno y muchos a muchos ejemplos de LSTM en Keras

Question

Trato de entender los LSTM y cómo construirlos con Keras. Descubrí que existen principalmente los 4 modos para ejecutar un RNN (los 4 correctos en la imagen)

Fuente de la imagen: Andrej Karpathy

Ahora me pregunto cómo se vería un fragmento de código minimalista para cada uno de ellos en Keras. Entonces algo como

model = Sequential()
model.add(LSTM(128, input_shape=(timesteps, data_dim)))
model.add(Dense(1))

para cada una de las 4 tareas, tal vez con un poco de explicación.

Answer 1

Asi que:

1. Uno a uno : puede usar una capa Dense ya que no está procesando secuencias:

    model.add(Dense(output_size, input_shape=input_shape))

2. Uno a muchos : esta opción no es compatible, ya que encadenar modelos no es muy fácil en Keras , por lo que la siguiente versión es la más fácil:

    model.add(RepeatVector(number_of_times, input_shape=input_shape))
    model.add(LSTM(output_size, return_sequences=True))

3. Muchos a uno : en realidad, su fragmento de código es (casi) un ejemplo de este enfoque:

    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim)))

4. Muchos a muchos : este es el fragmento más fácil cuando la longitud de la entrada y la salida coincide con el número de pasos recurrentes:

    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))

5. Muchos a muchos cuando el número de pasos difiere de la longitud de entrada / salida : esto es muy difícil en Keras. No hay fragmentos de código fáciles para codificar eso.

EDITAR: Anuncio 5

En una de mis aplicaciones recientes, implementamos algo que podría ser similar a muchos a muchos de la cuarta imagen. En caso de que desee tener una red con la siguiente arquitectura (cuando una entrada es más larga que la salida):

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | | | | 
                                  O O O O O O

Puede lograr esto de la siguiente manera:

    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))
    model.add(Lambda(lambda x: x[:, -N:, :]

Donde N es el número de últimos pasos que desea cubrir (en la imagen N = 3 ).

Desde este punto llegar a:

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | 
                                  O O O 

es tan simple como la secuencia de relleno artificial de longitud N usando, por ejemplo, con 0 vectores, para ajustarlo a un tamaño apropiado.

Answer 2

Gran respuesta de @Marcin Możejko

Agregaría lo siguiente a NR.5 (muchos a muchos con diferente longitud de entrada / salida):

A) como Vanilla LSTM

model = Sequential()
model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES)))
model.add(Dense(N_OUTPUTS))

B) como codificador-decodificador LSTM

model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES))  
model.add(RepeatVector(N_OUTPUTS))
model.add(LSTM(N_BLOCKS, return_sequences=True))  
model.add(TimeDistributed(Dense(1)))
model.add(Activation(''linear''))