web-dev-qa-db-fra.com

Comprendre la forme d’entrée Tensorflow LSTM

J'ai un jeu de données X qui se compose de N = 4000 échantillons, chaque échantillon étant constitué de d = 2 entités (valeurs continues) s'étalant sur t = 10 étapes de temps. J'ai également les «étiquettes» correspondantes de chaque échantillon, qui sont aussi des valeurs continues, à l'étape 11. 

Pour le moment, mon jeu de données a la forme X: [4000,20], Y: [4000].

Je souhaite former un LSTM à l'aide de TensorFlow pour prédire la valeur de Y (régression), compte tenu des 10 entrées précédentes de fonctions d, mais j'ai de la difficulté à mettre cela en œuvre dans TensorFlow.

Le principal problème que je rencontre pour le moment est de comprendre comment TensorFlow s'attend à ce que l'entrée soit formatée. J'ai vu divers exemples tels que this , mais ces exemples concernent une grande chaîne de données chronologiques continues. Mes données sont des échantillons différents, chacun étant une série chronologique indépendante.

pythontensorflowregressionlstm
16
Renier Botha

La documentation de tf.nn.dynamic_rnn déclare:

inputs: Les entrées RNN. Si time_major == False (par défaut), il doit s'agir d'un tenseur de forme: [batch_size, max_time, ...] ou d'un tuple imbriqué de tels éléments.

Dans votre cas, cela signifie que l'entrée doit avoir la forme [batch_size, 10, 2]. Au lieu de vous entraîner sur les 4 000 séquences à la fois, vous n’utiliseriez que batch_size nombre d’entre elles à chaque itération d’entraînement. Quelque chose comme ce qui suit devrait fonctionner (réorganiser pour plus de clarté):

batch_size = 32
# batch_size sequences of length 10 with 2 values for each timestep
input = get_batch(X, batch_size).reshape([batch_size, 10, 2])
# Create LSTM cell with state size 256. Could also use GRUCell, ...
# Note: state_is_Tuple=False is deprecated;
# the option might be completely removed in the future
cell = tf.nn.rnn_cell.LSTMCell(256, state_is_Tuple=True)
outputs, state = tf.nn.dynamic_rnn(cell,
                                   input,
                                   sequence_length=[10]*batch_size,
                                   dtype=tf.float32)

Dans documentation , outputs aura la forme [batch_size, 10, 256], c’est-à-dire une sortie 256 pour chaque pas de temps. state sera un Tuple de formes [batch_size, 256]. Vous pouvez prédire votre valeur finale, une pour chaque séquence, à partir de celle-ci:

predictions = tf.contrib.layers.fully_connected(state.h,
                                                num_outputs=1,
                                                activation_fn=None)
loss = get_loss(get_batch(Y).reshape([batch_size, 1]), predictions)

Le nombre 256 dans les formes de outputs et state est déterminé par cell.output_size resp. cell.state_size. Lors de la création de LSTMCell comme ci-dessus, ce sont les mêmes. Voir aussi la documentation LSTMCell .

8
fwalch