在 PyTorch 中，GRU / LSTM 模块的调用十分方便，以 GRU 为例，如下：

import torch
from torch.nn import LSTM, GRU
from torch.autograd import Variable
import numpy as np

# [batch_size, seq_len, input_feature_size]
random_input = Variable(torch.FloatTensor(1, 5, 1).normal_(), requires_grad=False)
gru = GRU( 
  input_size=1, hidden_size=1, num_layers=1, 
  batch_first=True, bidirectional=False
)
# output: [batch_size, seq_len, num_direction * hidden_size]
# hidden: [num_layers * num_directions, batch, hidden_size]
output, hidden = gru(random_input)

  其中，output[:, -1, :] 即为 hidden。LSTM 只是比 GRU 多了一个返回值 cell_state，其余不变。
  当我们将 bidirectional 参数设置为 True 的时候，GRU/LSTM 会自动地将两个方向的状态拼接起来。遇到一些序列分类问题，我们常常会将 Bi-GRU/LSTM 的最后一个隐状态输出到分类层中，也即使用 output[:, -1, :]，那么这样做是否正确呢？
  考虑这样一个问题：当模型正向遍历序列1, 2, 3, 4, 5 的时候，output[:, -1, :] 是依次计算节点 1～5 之后的隐状态；当模型反向遍历序列1, 2, 3, 4, 5 的时候，t = 5 位置对应的隐状态仅仅是计算了节点 5 之后的隐状态。output[:, -1, :] 就是拼接了上述两个向量的特征，但我们想要放入分类层的逆序特征应该是 t=1 位置对应的隐状态，也即依次遍历 5~1 节点、编码整个序列信息的特征。
  下面通过具体的代码佐证上述结论，样例主要参考 Understanding Bidirectional RNN in PyTorch：

1） 数据 & 模型准备

# import 如上
random_input = Variable(torch.FloatTensor(1, 5, 1).normal_(), requires_grad=False)
# random_input[0, :, 0]
# tensor([ 0.0929,  0.6335,  0.6090, -0.0992,  0.7811])

# 分别建立一个 双向 和 单向 GRU
bi_gru = GRU(input_size=1, hidden_size=1, num_layers=1, batch_first=True, bidirectional=True)
reverse_gru = GRU(input_size=1, hidden_size=1, num_layers=1, batch_first=True, bidirectional=False)

# 使 reverse_gru 的参数与 bi_gru 中逆序计算的部分保持一致
# 这样 reverse_gru 就可以等价于 bi_gru 的逆序部分
reverse_gru.weight_ih_l0 = bi_gru.weight_ih_l0_reverse
reverse_gru.weight_hh_l0 = bi_gru.weight_hh_l0_reverse
reverse_gru.bias_ih_l0 = bi_gru.bias_ih_l0_reverse
reverse_gru.bias_hh_l0 = bi_gru.bias_hh_l0_reverse

# random_input 正序输入 bi_gru，逆序输入 reverse_gru
bi_output, bi_hidden = bi_gru(random_input)
reverse_output, reverse_hidden = reverse_gru(random_input[:, np.arange(4, -1, -1), :])

2）结果对比

bi_output
'''
# shape = [1, 5, 2]
tensor([[[0.0867, 0.7053],
         [0.2305, 0.6983],
         [0.3245, 0.5996],
         [0.2290, 0.4437],
         [0.3471, 0.3395]]], grad_fn=<TransposeBackward1>)
'''

reverse_output
# shape = [1, 5, 1]
'''
tensor([[[0.3395],
         [0.4437],
         [0.5996],
         [0.6983],
         [0.7053]]], grad_fn=<TransposeBackward1>)
'''

  捋一捋，先只看 reverse_gru，这是个单向gru，我们输入了一个序列，那么编码了真格序列信息的隐状态自然是最后一个隐状态，也即 0.7053 是序列 [0.7811, -0.0992, 0.609, 0.6335, 0.0929] 的最后一个隐状态（序列向量）；bi_output 的第二列代表着逆向编码的结果，刚好是 reverse_output 的倒序，如果我们直接把 bi_output[:, -1, :] 作为序列向量，显然是不符合期望的。正确的做法是：

Method 1:
seq_vec = torch.cat(bi_output[:, -1, 0], bi_output[:, 0, 1])
'''
tensor([0.3471, 0.7053], grad_fn=<CatBackward>)
'''

Method 2:
seq_vec = bi_hidden.reshape([bi_hidden.shape[0], -1])
'''
tensor([[0.3471],
        [0.7053]], grad_fn=<ViewBackward>)
'''

  也即 hidden 这个变量是返回了 序列编码 的信息，满足了我们的要求，可以放心用，也推荐使用第二种方法，少做不必要折腾。

bi_hidden
'''
tensor([[[0.3471]],
        [[0.7053]]], grad_fn=<StackBackward>)
'''

reverse_hidden
'''
tensor([[[0.7053]]], grad_fn=<StackBackward>)
'''