空间深度学习——ConvLSTM原理及其TensorFlow实现

今天介绍一种很有名的网络结构——ConvLSTM，其不仅具有LSTM的时序建模能力，而且还能像CNN一样刻画局部特征，可以说是时空特性具备。

LSTM已经在语音识别、视频分析、序列建模等领域取得了非常精彩的进展，传统的LSTM网络由input gate, forget gate, cell, output gate, hidden五个模块组成，并且它们之间的关系可以由以下公式表示：



图中空心小圆圈表示矩阵对应元素相乘，又称为Hadamard乘积。这种LSTM结构我们也可以称之为FC-LSTM，因其内部门之间是依赖于类似前馈式神经网络来计算的，而这种FC-LSTM对于时序数据可以很好地处理，但是对于空间数据来说，将会带来冗余性，原因是空间数据具有很强的局部特征，但是FC-LSTM无法刻画此局部特征。本文提出的ConvLSTM尝试解决此问题，做法是将FC-LSTM中input-to-state和state-to-state部分由前馈式计算替换成卷积的形式，ConvLSTM的内部结构如下图所示：



从图中可以看出，此时输入与各个门之间的连接由前馈式替换成了卷积，同时状态与状态之间也换成了卷积运算。新的ConvLSTM的工作原理可以由以下公式表示：



图中*表示卷积，值得注意的是，这里的X,C,H,i,f,o都是三维的tensor，它们的后两个维度代表行和列的空间信息，我们可以把ConvLSTM想象成是处理二维网格中的特征向量的模型，其可以根据网格中周围点的特征来预测中心网格的特征。原理部分就介绍这么多了，接下来我们动手来实现一个ConvLSTM。

不过在实现之前，让我们先来看一下TensorFlow中常见的RNNCell的代码设计，TensorFlow中常见的RNNCell有BasicRNNCell，GRUCell以及LSTMCell，它们都是继承自RNNCell，并且都需要实现一个共同的方法就是call()，call的作用就是指明每一步循环时候input, state, output分别是什么关系。

就BasicRNNCell而言，其call方法只需接受input和state，输出它们之间的乘积并经过一个激活函数即可，核心代码如下：

def __call__(self, inputs, state, scope=None):
with _checked_scope(self, scope or "basic_rnn_cell", reuse=self._reuse):
output = self._activation(
_linear([inputs, state], self._num_units, True))
return output, output

1
2
3
4
5
1
2
3
4
5
[/code]

而相应的，GRUCell的核心代码如下：

def __call__(self, inputs, state, scope=None):
with _checked_scope(self, scope or "gru_cell", reuse=self._reuse):
with vs.variable_scope("gates"):
value = sigmoid(_linear(
[inputs, state], 2 * self._num_units, True, 1.0))
r, u = array_ops.split(
value=value,
num_or_size_splits=2,
axis=1)
with vs.variable_scope("candidate"):
c = self._activation(_linear([inputs, r * state],
self._num_units, True))
new_h = u * state + (1 - u) * c
return new_h, new_h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[/code]

BaiscLSTMCell的核心代码稍微会麻烦一点，因为它增加了多个门，而这里的state也不单单是一个变量，而是一个状态组合，为了提高矩阵运算效率，这里采取的方法是把图1中的四个运算表达式拼接到了一起同时计算，计算过后再将它们分开即可，最后再计算出c和h即可，由于这里并没有增加偏置，以及像c和i之间、c和f之间、c和h之间、c和o之间都没有建立连接，因此这个LSTMCell是BasicLSTMCell，而TensorFlow中还提供了带有peephole连接的LSTMCell，感兴趣的朋友可以直接看TensorFlow源码。

def __call__(self, inputs, state, scope=None):
with _checked_scope(self, scope or "basic_lstm_cell", reuse=self._reuse):
if self._state_is_tuple:
c, h = state
else:
c, h = array_ops.split(value=state, num_or_size_splits=2, axis=1)
concat = _linear([inputs, h], 4 * self._num_units, True)

i, j, f, o = array_ops.split(value=concat, num_or_size_splits=4, axis=1)

new_c = (c * sigmoid(f + self._forget_bias) + sigmoid(i) *
self._activation(j))
new_h = self._activation(new_c) * sigmoid(o)
if self._state_is_tuple:
new_state = LSTMStateTuple(new_c, new_h)
else:
new_state = array_ops.concat([new_c, new_h], 1)
return new_h, new_state

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[/code]

在写ConvLSTMCell的时候，我们可以完全模仿BasicLSTMCell的写法，只不过这里的所有变量维度都要增加，同时，对比图1和图3可知，无论是乘积还是卷积，都可以先拼接再拆分的方法来提高运算效率。下面自己写了一段代码，仅供参考，亲测可以运行。

import tensorflow as tf
import numpy as np

class BasicConvLSTMCell(tf.contrib.rnn.RNNCell):

def __init__(self, shape, num_filters, kernel_size, forget_bias=1.0,
input_size=None, state_is_tuple=True, activation=tf.nn.tanh, reuse=None):
self._shape = shape
self._num_filters = num_filters
self._kernel_size = kernel_size
self._size = tf.TensorShape(shape+[self._num_filters])

self._forget_bias = forget_bias
self._state_is_tuple = state_is_tuple
self._activation = activation
self._reuse = reuse  @property
def state_size(self):
return (tf.contrib.rnn.LSTMStateTuple(self._size, self._size)
if self._state_is_tuple else 2 * self._num_units)

@property
def output_size(self):
return self._size

def __call__(self, inputs, state, scope=None):
# we suppose inputs to be [time, batch_size, row, col, channel]
with tf.variable_scope(scope or "basic_convlstm_cell", reuse=self._reuse):
if self._state_is_tuple:
c, h = state
else:
c, h = array_ops.split(value=state, num_or_size_splits=2, axis=3)

inp_channel = inputs.get_shape().as_list()[-1]+self._num_filters
out_channel = self._num_filters * 4
concat = tf.concat([inputs, h], axis=3)

kernel = tf.get_variable('kernel', shape=self._kernel_size+[inp_channel, out_channel])
concat = tf.nn.conv2d(concat, filter=kernel, strides=(1,1,1,1), padding='SAME')

i, j, f, o = tf.split(value=concat, num_or_size_splits=4, axis=3)

new_c = (c * tf.sigmoid(f + self._forget_bias) + tf.sigmoid(i) *
self._activation(j))
new_h = self._activation(new_c) * tf.sigmoid(o)
if self._state_is_tuple:
new_state = tf.contrib.rnn.LSTMStateTuple(new_c, new_h)
else:
new_state = tf.concat([new_c, new_h], 3)
return new_h, new_state

if __name__ == '__main__':
inputs=tf.placeholder(tf.float32, [5,2,3,3,3])
cell = BasicConvLSTMCell([3,3], 6, [3,3])
outputs, state = tf.nn.dynamic_rnn(cell, inputs, dtype=inputs.dtype, time_major=True)
with tf.Session() as sess:
inp = np.random.normal(size=(5,2,3,3,3))
sess.run(tf.global_variables_initializer())
o, s = sess.run([outputs, state], feed_dict={inputs:inp})
print o.shape #(5,2,3,3,6)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
[/code]

.

相关github项目：

https://github.com/viorik/ConvLSTM

https://github.com/carlthome/tensorflow-convlstm-cell