LSTM Seguido por média de comparticipação

votos
6

Estou usando Keras 1.0. Meu problema é idêntico a este ( Como implementar uma camada média Pooling em Keras ), mas a resposta não parece ser suficiente para mim.

Eu quero implementar esta rede: digite

O código a seguir não funciona:

sequence = Input(shape=(max_sent_len,), dtype='int32')
embedded = Embedding(vocab_size, word_embedding_size)(sequence)
lstm = LSTM(hidden_state_size, activation='sigmoid', inner_activation='hard_sigmoid', return_sequences=True)(embedded)
pool = AveragePooling1D()(lstm)
output = Dense(1, activation='sigmoid')(pool)

Se eu não definir return_sequences=True, eu recebo este erro quando eu chamo AveragePooling1D():

Traceback (most recent call last):
  File <stdin>, line 1, in <module>
  File /PATH/keras/engine/topology.py, line 462, in __call__
    self.assert_input_compatibility(x)
  File /PATH/keras/engine/topology.py, line 382, in assert_input_compatibility
    str(K.ndim(x)))
Exception: ('Input 0 is incompatible with layer averagepooling1d_6: expected ndim=3', ' found ndim=2')

Caso contrário, eu recebo este erro quando eu chamo Dense():

Traceback (most recent call last):
  File <stdin>, line 1, in <module>
  File /PATH/keras/engine/topology.py, line 456, in __call__
    self.build(input_shapes[0])
  File /fs/clip-arqat/mossaab/trec/liveqa/cmu/venv/lib/python2.7/site-packages/keras/layers/core.py, line 512, in build
    assert len(input_shape) == 2
AssertionError
Publicado 05/04/2016 em 12:50
fonte usuário
Em outras línguas...                            


5 respostas

votos
4

Por favor, tente isso (eu espero que isso vai resolver o seu problema :)):

http://keras.io/layers/core/#timedistributedmerge

Respondeu 09/04/2016 em 22:55
fonte usuário

votos
2

Adicionando TimeDistributed(Dense(1))ajudou:

sequence = Input(shape=(max_sent_len,), dtype='int32')
embedded = Embedding(vocab_size, word_embedding_size)(sequence)
lstm = LSTM(hidden_state_size, activation='sigmoid', inner_activation='hard_sigmoid', return_sequences=True)(embedded)
distributed = TimeDistributed(Dense(1))(lstm)
pool = AveragePooling1D()(distributed)
output = Dense(1, activation='sigmoid')(pool)
Respondeu 24/06/2016 em 13:37
fonte usuário

votos
3

Acho que a resposta aceito é basicamente errado. A solução foi encontrada em: https://github.com/fchollet/keras/issues/2151 No entanto, ele só funciona para backend Theano. Eu modifiquei o código para que ele suporta tanto Teano e tensorflow.

from keras.engine.topology import Layer, InputSpec
from keras import backend as T

class TemporalMeanPooling(Layer):
    """
This is a custom Keras layer. This pooling layer accepts the temporal
sequence output by a recurrent layer and performs temporal pooling,
looking at only the non-masked portion of the sequence. The pooling
layer converts the entire variable-length hidden vector sequence
into a single hidden vector, and then feeds its output to the Dense
layer.

input shape: (nb_samples, nb_timesteps, nb_features)
output shape: (nb_samples, nb_features)
"""
def __init__(self, **kwargs):
    super(TemporalMeanPooling, self).__init__(**kwargs)
    self.supports_masking = True
    self.input_spec = [InputSpec(ndim=3)]

def get_output_shape_for(self, input_shape):
    return (input_shape[0], input_shape[2])

def call(self, x, mask=None): #mask: (nb_samples, nb_timesteps)
    if mask is None:
        mask = T.mean(T.ones_like(x), axis=-1)
    ssum = T.sum(x,axis=-2) #(nb_samples, np_features)
    mask = T.cast(mask,T.floatx())
    rcnt = T.sum(mask,axis=-1,keepdims=True) #(nb_samples)
    return ssum/rcnt
    #return rcnt

def compute_mask(self, input, mask):
    return None
Respondeu 28/11/2016 em 20:50
fonte usuário

votos
0

Obrigado, eu também atender a questão, mas acho camada TimeDistributed não funciona como você quer, você pode tentar camada TemporalMeanPooling de Lucas Guye, ele trabalha para mim. Aqui está o exemplo:

sequence = Input(shape=(max_sent_len,), dtype='int32')
embedded = Embedding(vocab_size, word_embedding_size)(sequence)
lstm = LSTM(hidden_state_size, return_sequences=True)(embedded)
pool = TemporalMeanPooling()(lstm)
output = Dense(1, activation='sigmoid')(pool)
Respondeu 25/03/2017 em 06:31
fonte usuário

votos
3

Eu só tentou implementar o mesmo modelo que o cartaz original, e eu estou usando Keras 2.0.3. A média pooling após LSTM funcionou quando usei GlobalAveragePooling1D, apenas certifique-se return_sequences=Truena camada LSTM. De uma chance!

Respondeu 20/04/2017 em 21:51
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more