Mehrdimensionale RNN auf Tensorflow

Question

Ich versuche, eine 2D-RNN im Rahmen der menschlichen Aktion Klassifizierung (Gelenke auf einer Achse der RNN und Zeit auf der anderen) zu implementieren und haben hoch und niedrig für etwas im Tensorflow, die könnte mach den Job.

ich von GridLSTMCell gehört (internally und externally beigetragen) konnte aber nicht mit dynamic_rnn (nimmt einen 3-D-Tensor zu arbeiten, aber ich würde ein 4-D-Tensor [batchsize, MAX_TIME, num_joints zu bieten haben, n_features]). Die ist auch eine (etwas unbekannte) part der TF-Bibliothek, die im Grunde ein normales 1-D-LSTM verwendet und die Ausgabe transponiert, um sie in ein zweites 1-D-LSTM zu speisen. Dies wurde auch befürwortet here, aber ich bin mir nicht sicher, ob es richtig ist/wenn es die gleiche Idee ist, als was ich brauchen würde.

Jede Hilfe wäre willkommen.

Answer 1

Ich habe erfolgreich versucht mit GridLSTM und in Tensorflow.

Ich bin nicht sicher, wie man einen 4D-Tensor in eine 3D umzuwandeln für sie von einem dynamic_rnn in Kauf genommen werden, aber ich denke, das Ihnen eine Idee geben könnte, wie GridLSTM verwenden:

def reshape_to_rnn_dims(tensor, num_time_steps): 
    return tf.unstack(tensor, num_time_steps, 1) 


class GridLSTMCellTest(tf.test.TestCase): 
    def setUp(self): 
     self.num_features = 1 
     self.time_steps = 1 
     self.batch_size = 1 
     tf.reset_default_graph() 
     self.input_layer = tf.placeholder(tf.float32, [self.batch_size, self.time_steps, self.num_features]) 
     self.cell = grid_rnn.Grid1LSTMCell(num_units=8) 

    def test_simple_grid_rnn(self): 
     self.input_layer = reshape_to_rnn_dims(self.input_layer, self.time_steps) 
     tf.nn.static_rnn(self.cell, self.input_layer, dtype=tf.float32) 

    def test_dynamic_grid_rnn(self): 
     tf.nn.dynamic_rnn(self.cell, self.input_layer, dtype=tf.float32) 


class BidirectionalGridRNNCellTest(tf.test.TestCase): 
    def setUp(self): 
     self.num_features = 1 
     self.time_steps = 1 
     self.batch_size = 1 
     tf.reset_default_graph() 
     self.input_layer = tf.placeholder(tf.float32, [self.batch_size, self.time_steps, self.num_features]) 
     self.cell_fw = grid_rnn.Grid1LSTMCell(num_units=8) 
     self.cell_bw = grid_rnn.Grid1LSTMCell(num_units=8) 

    def test_simple_bidirectional_grid_rnn(self): 
     self.input_layer = reshape_to_rnn_dims(self.input_layer, self.time_steps) 
     tf.nn.static_bidirectional_rnn(self.cell_fw, self.cell_fw, self.input_layer, dtype=tf.float32) 

    def test_bidirectional_dynamic_grid_rnn(self): 
     tf.nn.bidirectional_dynamic_rnn(self.cell_fw, self.cell_bw, self.input_layer, dtype=tf.float32) 

if __name__ == '__main__': 
    tf.test.main() 

offenbar ndlstm s 4D Tensoren mit der (batch_size, height, width, depth) Form annehmen, ich diese Tests haben (. man die Verwendung von tensorflow der Beteiligung ctc_loss fand auch eine example seiner Verwendung mit conv2d):

class MultidimensionalRNNTest(tf.test.TestCase): 
    def setUp(self): 
     self.num_classes = 26 
     self.num_features = 32 
     self.time_steps = 64 
     self.batch_size = 1 # Can't be dynamic, apparently. 
     self.num_channels = 1 
     self.num_filters = 16 
     self.input_layer = tf.placeholder(tf.float32, [self.batch_size, self.time_steps, self.num_features, self.num_channels]) 
     self.labels = tf.sparse_placeholder(tf.int32) 

    def test_simple_mdrnn(self): 
     net = lstm2d.separable_lstm(self.input_layer, self.num_filters) 

    def test_image_to_sequence(self): 
     net = lstm2d.separable_lstm(self.input_layer, self.num_filters) 
     net = lstm2d.images_to_sequence(net) 

    def test_convert_to_ctc_dims(self): 
     net = lstm2d.separable_lstm(self.input_layer, self.num_filters) 
     net = lstm2d.images_to_sequence(net) 

     net = tf.reshape(inputs, [-1, self.num_filters]) 

     W = tf.Variable(tf.truncated_normal([self.num_filters, 
            self.num_classes], 
            stddev=0.1, dtype=tf.float32), name='W') 
     b = tf.Variable(tf.constant(0., dtype=tf.float32, shape=[self.num_classes], name='b')) 

     net = tf.matmul(net, W) + b 
     net = tf.reshape(net, [self.batch_size, -1, self.num_classes]) 

     net = tf.transpose(net, (1, 0, 2)) 

     loss = tf.nn.ctc_loss(inputs=net, labels=self.labels, sequence_length=[2]) 

    print(net) 


if __name__ == '__main__': 
    tf.test.main()