本文主要是有关convLSTM的pytorch实现代码的理解，原理请移步其他博客。

在pytorch中实现LSTM或者GRU等RNN一般需要重写cell，每个cell中包含某一个时序的计算，也就是以下：

在传统LSTM中，LSTM每次要调用t次cell，t就是时序的总长度，如果是n层LSTM就相当于一共调用了n*t次cell

class ConvLSTMCell(nn.Module):

    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):
        """
        Initialize ConvLSTM cell.

        Parameters
        ----------
        input_size: (int, int)
            Height and width of input tensor as (height, width).
        input_dim: int
            Number of channels of input tensor.
        hidden_dim: int
            Number of channels of hidden state.
        kernel_size: (int, int)
            Size of the convolutional kernel.
        bias: bool
            Whether or not to add the bias.
        """

        super(ConvLSTMCell, self).__init__()

        self.height, self.width = input_size
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim

        self.kernel_size = kernel_size
        self.padding = kernel_size[0] // 2, kernel_size[1] // 2
        self.bias = bias

        self.conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,
                              out_channels=4 * self.hidden_dim,
                              kernel_size=self.kernel_size,
                              padding=self.padding,
                              bias=self.bias)

    def forward(self, input_tensor, cur_state):
        '''
        :param input_tensor:[batch,dim,inp_height,inp_width]
        :param cur_state: [h,c] h:[batch,dim,H,W]
        :return:
        '''
        h_cur, c_cur = cur_state

        combined = torch.cat([input_tensor, h_cur], dim=1)  

        combined_conv = self.conv(combined)
        cc_i, cc_f, cc_o, cc_g = torch.split(combined_conv, self.hidden_dim, dim=1)
        i = torch.sigmoid(cc_i)
        f = torch.sigmoid(cc_f)
        o = torch.sigmoid(cc_o)
        g = torch.tanh(cc_g)

        c_next = f * c_cur + i * g
        h_next = o * torch.tanh(c_next)

        return h_next, c_next

    def init_hidden(self, batch_size):
        return (Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)),
                Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)))

 cell的实现主要如上，其中可以看出来，参数是通过一次Conv2d的调用就申请好的，这里是这样理解的：

in_channels=self.input_dim + self.hidden_dim

out_channels=4 * self.hidden_dim

由于在计算 i f c o 时我们都引入了卷积运算，且运算的对象都是一样的，要么是对当前时序的输入input要么是对上一时刻的输出h，所以Wxi Wxf Wcf Wxo的卷积核规模或者说参数的规模是相同的，是相同size的tensor，同理Whi Whf Whc Wco也是一样。

在当前时刻，我们的输入有input[batch,input_dim,H,W]，h[batch,hidden_dim,H,W]（这里的input和h的HW是相同的，因为在设置卷积padding的时候约定了输入的规模）然后我们通过torch.cat将输入合并为[batch,input_dim+hidden_dim,H,W]

此时我们的核规模是[4*hidden_dim,input_dim+hidden_dim,kH,kW]

在卷积过程中，这里参考pytorch文档

 这个公式可以理解为矩阵乘运算，不过矩阵乘运算中进行的是每个元素相乘相加，这里的矩阵乘运算是矩阵中每个核和每个输入的tensor进行卷积操作再相加。

举个栗子

假设我们的输入是28*28的手写体，为了符合时序的要求，我们将手写体划分为16个时序的7*7图片，核大小设置为(3,3)，此时我们的输入输出的dim都是1，所以以上的input=[batch,1,7,7] h=[batch,1,7,7] core=[4,2,3,3]

不考虑bias结果就如图所示了，所以再经过一次split切割，就能拿到很多中间步骤的结果啦。