deep-learning - timedistributed - lstm keras

¿Cómo usar la opción return_sequences y la capa TimeDistributed en Keras?

Question

Tengo un corpus de diálogo como el de abajo. Y quiero implementar un modelo LSTM que predice una acción del sistema. La acción del sistema se describe como un vector de bits. Y una entrada del usuario se calcula como una inserción de palabras que también es un vector de bits.

t1: user: "Do you know an apple?", system: "no"(action=2)
t2: user: "xxxxxx", system: "yyyy" (action=0)
t3: user: "aaaaaa", system: "bbbb" (action=5)

Entonces, lo que quiero realizar es el modelo "muchos a muchos (2)". Cuando mi modelo recibe una entrada del usuario, debe generar una acción del sistema. Pero no puedo entender la opción TimeDistributed y la capa TimeDistributed después de LSTM. Para obtener "muchos a muchos (2)", return_sequences==True y agregar un TimeDistributed después de que se requieren LSTMs? Aprecio si les darías más descripción de ellos.

return_sequences : Boolean. Si se debe devolver la última salida en la secuencia de salida o la secuencia completa.

TimeDistributed : esta envoltura permite aplicar una capa a cada segmento temporal de una entrada.

Actualizado 2017/03/13 17:40

Creo que pude entender la opción return_sequence . Pero todavía no estoy seguro de TimeDistributed . Si agrego un TimeDistributed after LSTMs, ¿el modelo es el mismo que "my many-to-many (2)"? Así que creo que se aplican capas densas para cada salida.

Answer 1

La capa LSTM y el envoltorio TimeDistributed son dos formas diferentes de obtener la relación "de muchos a muchos" que desea.

1. LSTM comerá las palabras de su oración una por una, puede elegir a través de "return_sequence" para que salga de algo (el estado) en cada paso (después de cada palabra procesada) o solo envíe algo después de haber comido la última palabra. Entonces, con return_sequence = TRUE, la salida será una secuencia de la misma longitud, con return_sequence = FALSE, la salida será solo un vector.
2. Tiempo distribuido. Esta envoltura le permite aplicar una capa (por ejemplo, denso) a cada elemento de su secuencia de forma independiente . Esa capa tendrá exactamente los mismos pesos para cada elemento, es la misma que se aplicará a cada palabra y, por supuesto, devolverá la secuencia de palabras procesadas de forma independiente.

Como puede ver, la diferencia entre los dos es que el LSTM "propaga la información a través de la secuencia, ingerirá una palabra, actualizará su estado y la devolverá o no. Luego continuará con la siguiente palabra mientras aún lleva información. de los anteriores ... como en TimeDistributed, las palabras se procesarán de la misma manera, como si estuvieran en silos y la misma capa se aplica a cada uno de ellos.

Para no tener que usar LSTM y TimeDistributed en una fila, puede hacer lo que quiera, solo tenga en cuenta lo que hace cada uno de ellos.

Espero que sea más claro?

EDITAR:

El tiempo distribuido, en su caso, aplica una capa densa a cada elemento que fue emitido por el LSTM.

Tomemos un ejemplo:

Tiene una secuencia de n_words palabras que están incrustadas en dimensiones emb_size. Entonces, su entrada es un tensor de forma 2D (n_words, emb_size)

Primero aplica un LSTM con dimensión de salida = lstm_output y return_sequence = True . La salida seguirá siendo una secuencia, por lo que será un tensor de forma 2D (n_words, lstm_output) . Así que tienes n_words vectores de longitud lstm_output.

Ahora aplica una capa densa TimeDistributed con, por ejemplo, 3 dimensiones de salida como parámetro de la densidad. Por lo tanto, TimeDistributed (Dense (3)). Esto aplicará tiempos densos (3) n_words, a cada vector de tamaño lstm_output en su secuencia de forma independiente ... todos se convertirán en vectores de longitud 3. Su salida seguirá siendo una secuencia, por lo que un tensor 2D, de forma ahora (n_words, 3) .

¿Está más claro? :-)

Answer 2

    return_sequences=True parameter:

Si queremos tener una secuencia para la salida, no solo un vector como hicimos con las redes neuronales normales, es necesario que establezcamos el valor de return_sequences en True. Concretamente, digamos que tenemos una entrada con forma (num_seq, seq_len, num_feature). Si no establecemos return_sequences = True, nuestra salida tendrá la forma (num_seq, num_feature), pero si lo hacemos, obtendremos la salida con forma (num_seq, seq_len, num_feature).

    TimeDistributed wrapper layer:

Dado que establecimos return_sequences = True en las capas LSTM, la salida ahora es un vector de tres dimensiones. Si ingresamos eso en la capa Densa, generará un error porque la capa Densa solo acepta entradas de dos dimensiones. Para ingresar un vector de tres dimensiones, necesitamos usar una capa de envoltura llamada TimeDistributed. Esta capa nos ayudará a mantener la forma de la salida, para que podamos lograr una secuencia como salida al final.