python - contrib - tensorflow lstm cell

Entender la forma de entrada del Tensorflow LSTM

Question

Tengo un conjunto de datos X que consta de N = 4000 muestras , cada muestra consta de d = 2 características (valores continuos) que abarcan t = 10 pasos de tiempo . También tengo las ''etiquetas'' correspondientes de cada muestra que también son valores continuos, en el paso de tiempo 11.

Por el momento, mi conjunto de datos tiene la forma X: [4000,20], Y: [4000].

Quiero entrenar un LSTM usando TensorFlow para predecir el valor de Y (regresión), dadas las 10 entradas previas de las características d, pero estoy teniendo dificultades para implementar esto en TensorFlow.

El principal problema que tengo en este momento es entender cómo TensorFlow espera que la entrada sea formateada. He visto varios ejemplos como este , pero estos ejemplos se refieren a una gran cadena de datos de series temporales continuas. Mis datos son muestras diferentes, cada una una serie de tiempo independiente.

Gracias.

Answer 1

La documentación de tf.nn.dynamic_rnn indica:

inputs : las inputs RNN. Si time_major == False (por defecto), debe ser un Tensor de forma: [batch_size, max_time, ...] , o una tupla anidada de dichos elementos.

En su caso, esto significa que la entrada debe tener una forma de [batch_size, 10, 2] . En lugar de entrenar en todas las 4000 secuencias a la vez, usaría solo batch_size muchas de ellas en cada iteración de entrenamiento. Debería funcionar algo como lo siguiente (remodelación adicional para mayor claridad):

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)

De la documentación , los outputs serán de forma [batch_size, 10, 256] , es decir, una salida de 256 para cada paso de tiempo. state será una tupla de formas [batch_size, 256] . Podrías predecir tu valor final, uno para cada secuencia, a partir de eso:

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)

El número 256 en las formas de las outputs y el state está determinado por cell.output_size resp. cell.state_size . Al crear el LSTMCell como el anterior, estos son iguales. También vea la documentación de LSTMCell .