Comment utiliser multicouche bidirectionnel LSTM dans Tensorflow?

Je veux savoir comment utiliser multicouche bidirectionnel LSTM dans Tensorflow.

J'ai déjà mis en œuvre le contenu de la bidirectionnel LSTM, mais j'ai envie de comparer ce modèle avec le modèle ajouté multi-couches.

Comment dois-je ajouter un peu de code dans cette partie?

x = tf.unstack(tf.transpose(x, perm=[1, 0, 2]))
#print(x[0].get_shape())

# Define lstm cells with tensorflow
# Forward direction cell
lstm_fw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
# Backward direction cell
lstm_bw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

# Get lstm cell output
try:
    outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
                                          dtype=tf.float32)
except Exception: # Old TensorFlow version only returns outputs not states
    outputs = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
                                    dtype=tf.float32)

# Linear activation, using rnn inner loop last output
outputs = tf.stack(outputs, axis=1)
outputs = tf.reshape(outputs, (batch_size*n_steps, n_hidden*2))
outputs = tf.matmul(outputs, weights['out']) + biases['out']
outputs = tf.reshape(outputs, (batch_size, n_steps, n_classes))

OriginalL'auteur Gi Yeon Shin | 2017-09-13

  1. 4

    Vous pouvez utiliser deux approches différentes pour appliquer multicouche bilstm modèle:

    1) utilisation en dehors de la précédente bilstm la couche d'entrée à la prochaine bilstm. Au début, vous devriez créer des tableaux avec en avant et en arrière des cellules de longueur num_layers. Et 

    for n in range(num_layers):
        cell_fw = cell_forw[n]
        cell_bw = cell_back[n]

        state_fw = cell_fw.zero_state(batch_size, tf.float32)
        state_bw = cell_bw.zero_state(batch_size, tf.float32)

        (output_fw, output_bw), last_state = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, output,
                                                                             initial_state_fw=state_fw,
                                                                             initial_state_bw=state_bw,
                                                                             scope='BLSTM_'+ str(n),
                                                                             dtype=tf.float32)

        output = tf.concat([output_fw, output_bw], axis=2)

    2) Aussi mérite un coup d'oeil à une autre approche empilés bilstm.

    J'ai essayé et eu cette erreur: ValueError: Variable bidirectional_rnn/fw/lstm_cell/kernel existe déjà, rejetés. Vouliez-vous dire pour définir la réutilisation=True dans VarScope? Pouvez-vous fournir un exemple?

    OriginalL'auteur Taras Khakhulin

  2. 5

    C'est essentiellement la même que la première réponse, mais avec un peu de variation de l'utilisation du nom de l'étendue et de décrochage des wrappers. Il s'occupe aussi de l'erreur de la première réponse donne sur la portée des variables.

    def bidirectional_lstm(input_data, num_layers, rnn_size, keep_prob):

    output = input_data
    for layer in range(num_layers):
        with tf.variable_scope('encoder_{}'.format(layer),reuse=tf.AUTO_REUSE):

            # By giving a different variable scope to each layer, I've ensured that
            # the weights are not shared among the layers. If you want to share the
            # weights, you can do that by giving variable_scope as "encoder" but do
            # make sure first that reuse is set to tf.AUTO_REUSE

            cell_fw = tf.contrib.rnn.LSTMCell(rnn_size, initializer=tf.truncated_normal_initializer(-0.1, 0.1, seed=2))
            cell_fw = tf.contrib.rnn.DropoutWrapper(cell_fw, input_keep_prob = keep_prob)

            cell_bw = tf.contrib.rnn.LSTMCell(rnn_size, initializer=tf.truncated_normal_initializer(-0.1, 0.1, seed=2))
            cell_bw = tf.contrib.rnn.DropoutWrapper(cell_bw, input_keep_prob = keep_prob)

            outputs, states = tf.nn.bidirectional_dynamic_rnn(cell_fw, 
                                                              cell_bw, 
                                                              output,
                                                              dtype=tf.float32)

            # Concat the forward and backward outputs
            output = tf.concat(outputs,2)

    return output
    J'ai une question par rapport à ça. Je concat les sorties et remodelé à l'aide de output = tf.reshape(tf.concat(output,1), [-1, 2 * rnn_size]) et la dimension est désormais (Batch_size X échéances, 2*rnn_size). Quand je l'ai passer au travers d'une couche dense en utilisant logits=tf.matmul(output, weight) + bias, ma dimension devient (Batch_size X échéances, num_classes). Ce sont mes logits. Comment puis-je trouver de la perte par l'utilisation de tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y))? cause de la forme de l'espace réservé Y est [None, num_classes].
    Vous ne pouvez pas directement. Vous devez éliminer timestep dimension. Est-il une raison particulière d'utiliser la sortie de toutes les échéances? Généralement, nous prenons la sortie du dernier pas de temps seulement. Vous pouvez le faire en retournant output = output[:,-1,:]. Maintenant logits serait [batch_size,num_classes]
    merci beaucoup pour votre réponse rapide. Pour être honnête, c'est comment j'ai appris LSTM. Comme dans cet exemple elles s'aplatissent la sortie et les utiliser pour calculer des logits, de ne pas éliminer les échéances. Je suis un peu confus maintenant.
    Il a fait cela parce qu'il l'aide tf.contrib.seq2seq.sequence_loss dont on attend la time_step dimension. Notez qu'une fois logits sont calculés, il a de nouveau remodelé il à la forme d'origine. Dans votre cas, vous souhaitez utiliser tf.nn.softmax_cross_entropy_with_logits qui ne prendra pas cette forme. Il faudra la dernière time_step seulement.
    Oh, je comprends.donc, vous dites que, avant de couche dense et softwax, je devrais choisir la dernière fois que les étapes de points de données et à partir de là?

    OriginalL'auteur mnis

  3. 1

    Sur le dessus de Taras réponse. Voici un autre exemple à l'aide de seulement 2 couches Bidirectionnel RNN avec GRU cellules 

        embedding_weights = tf.Variable(tf.random_uniform([vocabulary_size, state_size], -1.0, 1.0))
    embedding_vectors = tf.nn.embedding_lookup(embedding_weights, tokens)

    #First BLSTM
    cell = tf.nn.rnn_cell.GRUCell(state_size)
    cell = tf.nn.rnn_cell.DropoutWrapper(cell, output_keep_prob=1-dropout)
    (forward_output, backward_output), _ = \
        tf.nn.bidirectional_dynamic_rnn(cell, cell, inputs=embedding_vectors,
                                        sequence_length=lengths, dtype=tf.float32,scope='BLSTM_1')
    outputs = tf.concat([forward_output, backward_output], axis=2)

    #Second BLSTM using the output of previous layer as an input.
    cell2 = tf.nn.rnn_cell.GRUCell(state_size)
    cell2 = tf.nn.rnn_cell.DropoutWrapper(cell2, output_keep_prob=1-dropout)
    (forward_output, backward_output), _ = \
        tf.nn.bidirectional_dynamic_rnn(cell2, cell2, inputs=outputs,
                                        sequence_length=lengths, dtype=tf.float32,scope='BLSTM_2')
    outputs = tf.concat([forward_output, backward_output], axis=2)

    BTW, n'oubliez pas d'ajouter un autre champ nom. Espérons que cette aide.

    OriginalL'auteur Ekkalak Thongthanomkul

  4. 1

    @Taras souligné, vous pouvez utiliser:

    (1) tf.nn.bidirectional_dynamic_rnn()

    (2) tf.contrib.rnn.stack_bidirectional_dynamic_rnn().

    Toutes les réponses précédentes ne capturer (1), donc, je donne quelques détails sur (2), en particulier puisqu'elle surpasse généralement (1). Pour une intuition sur les différentes connectivités
    voir ici.

    Disons que vous voulez créer une pile de 3 BLSTM couches, chacune avec 64 nœuds:

    num_layers = 3
num_nodes = 64


# Define LSTM cells
enc_fw_cells = [LSTMCell(num_nodes)for layer in range(num_layers)]
enc_bw_cells = [LSTMCell(num_nodes) for layer in range(num_layers)]

# Connect LSTM cells bidirectionally and stack
(all_states, fw_state, bw_state) = tf.contrib.rnn.stack_bidirectional_dynamic_rnn(
        cells_fw=enc_fw_cells, cells_bw=enc_bw_cells, inputs=input_embed, dtype=tf.float32)

# Concatenate results
for k in range(num_layers):
    if k == 0:
        con_c = tf.concat((fw_state[k].c, bw_state[k].c), 1)
        con_h = tf.concat((fw_state[k].h, bw_state[k].h), 1)
    else:
        con_c = tf.concat((con_c, fw_state[k].c, bw_state[k].c), 1)
        con_h = tf.concat((con_h, fw_state[k].h, bw_state[k].h), 1)

output = tf.contrib.rnn.LSTMStateTuple(c=con_c, h=con_h)

    Dans ce cas, j'utilise la finale des états de la pile de biRNN plutôt que les états, à toutes les échéances (enregistré dans all_states), depuis que j'ai été en utilisant un codage décodage régime, où le code ci-dessus n'était que le codeur.

    OriginalL'auteur dopexxx