comment pile LSTM en utilisant des couches de TensorFlow

ce que j'ai est le suivant, je crois que c'est un réseau avec un caché LSTM couche:

# Parameters
learning rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10

# Network Parameters
n_input = 13
n_steps = 10
n_hidden = 512
n_classes = 13

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes])

# Define weights
weights = {
    'out' : tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
    'out' : tf.Variable(tf.random_normal([n_classes]))
}

Cependant, je suis en train de construire un LSTM réseau à l'aide de TensorFlow de prédire la consommation d'énergie. J'ai été en regardant autour de vous pour trouver un bon exemple, mais je ne pouvais pas trouver un modèle avec 2 cachés LSTM couches. Voici le modèle que je voudrais construire:

1 couche d'entrée,
1 couche de sortie,
2 cachés LSTM couches(avec 512 neurones dans chacune),
pas de temps(longueur de la séquence): 10

Quelqu'un pourrait-il me guider pour construire cette aide TensorFlow? ( à partir de la définition des poids, des entrées dans la construction de la forme, de la formation, de la prévision et de l'utilisation de l'optimiseur ou de la fonction de coût, etc), toute aide serait grandement appréciée.

Je vous remercie beaucoup d'avance!

OriginalL'auteur subbie | 2016-08-25

  1. 5

    Ici est de savoir comment je le fais dans un modèle de traduction avec GRU cellules. Vous pouvez simplement remplacer le GRU avec un LSTM. Il est vraiment facile de simplement utiliser tf.nn.rnn_cell.MultiRNNCell avec une liste de plusieurs cellules, il doit envelopper. Dans le code soufflet je suis dérouler manuellement, mais vous pouvez le passer à tf.nn.dynamic_rnn ou tf.nn.rnn.

    y = input_tensor
with tf.variable_scope('encoder') as scope:
    rnn_cell = rnn.MultiRNNCell([rnn.GRUCell(1024) for _ in range(3)])
    state = tf.zeros((BATCH_SIZE, rnn_cell.state_size))
    output = [None] * TIME_STEPS
    for t in reversed(range(TIME_STEPS)):
        y_t = tf.reshape(y[:, t, :], (BATCH_SIZE, -1))
        output[t], state = rnn_cell(y_t, state)
        scope.reuse_variables()
    y = tf.pack(output, 1)
    Merci pour la réponse. Dois-je encore besoin d'initialiser des variables(paramètres) à partir de caché layer1 cachés layer2 ou sont-ils à l'interne?
    Les variables de la LSTM de l'initialisation lorsque vous l'utilisez à l'intérieur de la classe. Regardez le code source, il est assez utile.
    Je vois que les variables pour les quatre portes de la LSTM de l'initialisation, mais ne devrait-il pas également être des paramètres à partir de la première couche cachée à la seconde? Il ferait de sens si MultiRNNCell initialise les paramètres à partir d'un caché à l'autre.
    Je ne suis pas sûr de ce que tu veux dire. Il crée de toutes les variables dont vous avez besoin.

    OriginalL'auteur chasep255

  2. 2

    D'abord vous avez besoin de quelques espaces réservés pour mettre vos données d'entraînement (un lot)

    x_input = tf.placeholder(tf.float32, [batch_size, truncated_series_length, 1])
y_output = tf.placeholder(tf.float32, [batch_size, truncated_series_length, 1])

    Un LSTM besoin d'un etat, qui se compose de deux composants, l'état caché et l'état de la cellule, très bon guide ici: https://arxiv.org/pdf/1506.00019.pdf. Pour chaque couche dans la LSTM vous avez un état de la cellule et un état caché.

    Le problème est que Tensorflow les enregistre dans une LSTMStateTuple laquelle vous ne pouvez pas envoyer dans l'espace réservé. Si vous avez besoin de le stocker dans un Tenseur, puis décompressez dans un n-uplet:

    state_placeholder = tf.placeholder(tf.float32, [num_layers, 2, batch_size, state_size])

l = tf.unpack(state_placeholder, axis=0)
rnn_tuple_state = tuple(
    [tf.nn.rnn_cell.LSTMStateTuple(l[idx][0], l[idx][1])
     for idx in range(num_layers)]
)

    Ensuite, vous pouvez utiliser le haut-Tensorflow API pour créer le empilés LSTM couche.

    cell = tf.nn.rnn_cell.LSTMCell(state_size, state_is_tuple=True)
cell = tf.nn.rnn_cell.MultiRNNCell([cell]*num_layers, state_is_tuple=True)
outputs, state = tf.nn.dynamic_rnn(cell, x_input, initial_state=rnn_tuple_state)

    De là, vous continuez avec les sorties de calculer les logits puis une perte à l'égard de la y_inputs.

    Ensuite, vous exécutez chaque lot avec le sess.run-commande, avec tronqué les (bonne explication ici http://r2rt.com/styles-of-truncated-backpropagation.html)

     init_state = np.zeros((num_layers, 2, batch_size, state_size))

...current_state... = sess.run([...state...], feed_dict={x_input:batch_in, state_placeholder:current_state ...})
current_state = np.array(current_state)

    Vous devez la convertir en l'état à un numpy tableau avant de nourrir à nouveau.

    Peut-être qu'il est préférable d'utiliser un librarly comme Tflearn ou Keras à la place?

    Ne souhaitez pas modifier car il dépend de la tensorflow Version que vous utilisez: Mais il semble que la tf.déballez a changé de tf.dépiler

    OriginalL'auteur user1506145