序列模型和LSTM网络(长短记忆网络)

    之前我们已经学过了许多的前馈网络. 所谓前馈网络, 就是网络中不会保存状态. 然而有时 这并不是我们想要的效果. 在自然语言处理 (NLP, Natural Language Processing) 中, 序列模型是一个核心的概念. 所谓序列模型, 即输入依赖于时间信息的模型. 一个典型的序列模型是隐马尔科夫模型 (HMM, Hidden Markov Model). 另一个序列模型的例子是条件随机场 (CRF, Conditional Random Field).

    循环神经网络是指可以保存某种状态的神经网络. 比如说, 神经网络中上个时刻的输出可以作为下个 时刻的输入的一部分, 以此信息就可以通过序列在网络中一直往后传递. 对于LSTM (Long-Short Term Memory) 来说, 序列中的每个元素都有一个相应的隐状态 $h_t$, 该隐状态 原则上可以包含序列当前结点之前的任一节点的信息. 我们可以使用隐藏状态来预测语言模型 中的单词, 词性标签以及其他各种各样的东西.

    在正式学习之前，有几个点要说明一下，Pytorch中LSTM的输入形式是一个3D的Tensor，每一个维度都有重要的意义，第一个维度就是序列本身，第二个维度是mini-batch中实例的索引，第三个维度是输入元素的索引，我们之前没有接触过mini-batch，所以我们就先忽略它并假设第二维的维度是1。

    如果要用”The cow jumped”这个句子来运行一个序列模型，那么就应该把它整理成如下的形式：

    \begin{split}\begin{bmatrix} \overbrace{q\text{The}}^\text{row vector} \ q\text{cow} \ q_\text{jumped} \end{bmatrix}\end{split}

    除了有一个额外的大小为1的第二维度.

    来看一个简单的例子.

    2. inputs = [torch.randn(1, 3) for _ in range(5)]  # 生成一个长度为5的序列
    4. # 初始化隐藏状态.
    5. hidden = (torch.randn(1, 1, 3),
    6.           torch.randn(1, 1, 3))
    7. for i in inputs:
    8.     # 将序列中的元素逐个输入到LSTM.
    9.     # 经过每步操作,hidden 的值包含了隐藏状态的信息.
    10.     out, hidden = lstm(i.view(1, 1, -1), hidden)
    12. # 另外我们可以对一整个序列进行训练.
    13. # LSTM第一个返回的第一个值是所有时刻的隐藏状态
    14. # 第二个返回值是最后一个时刻的隐藏状态
    15. #(所以"out"的最后一个和"hidden"是一样的)
    16. # 之所以这样设计:
    17. # 通过"out"你能取得任何一个时刻的隐藏状态，而"hidden"的值是用来进行序列的反向传播运算, 具体方式就是将它作为参数传入后面的 LSTM 网络.
    19. # 增加额外的第二个维度.
    20. inputs = torch.cat(inputs).view(len(inputs), 1, -1)
    21. hidden = (torch.randn(1, 1, 3), torch.randn(1, 1, 3))  # 清空隐藏状态. 
    22. out, hidden = lstm(inputs, hidden)
    23. print(out)
    24. print(hidden)

    输出:

    在这部分, 我们将会使用一个 LSTM 网络来进行词性标注. 在这里我们不会用到维特比算法, 前向-后向算法或者任何类似的算法,而是将这部分内容作为一个 (有挑战) 的练习留给读者, 希望读者在了解了这部分的内容后能够实现如何将维特比算法应用到 LSTM 网络中来.

    该模型如下:输入的句子是w1,…,wM​对应的词性为y_1, …,y_M​ ，用\hat{y}_i​表示对单词w_i​词性的预测，标签的集合定义为T。

    这是一个结构预测模型, 我们的输出是一个序列\hat{y}_1,…,\hat{y}_M, 其中\hat{y}_i\in T.

    在进行预测时, 需将句子每个词输入到一个 LSTM 网络中. 将时刻i​的隐藏状态标记为h_i​,同样地, 对每个标签赋一个独一无二的索引 (类似 word embeddings 部分 word_to_ix 的设置). 然后就得到了\hat{y}_i​的预测规则。

    \hat{y}^i=argmaxj (logSoftmax(Ahi+b))j​

    准备数据:

    1. def prepare_sequence(seq, to_ix):
    2.     return torch.tensor(idxs, dtype=torch.long)
    4. training_data = [
    5.     ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
    6.     ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
    7. ]
    8. word_to_ix = {}
    9. for sent, tags in training_data:
    10.     for word in sent:
    11.         if word not in word_to_ix:
    12.             word_to_ix[word] = len(word_to_ix)
    13. print(word_to_ix)
    14. tag_to_ix = {"DET": 0, "NN": 1, "V": 2}
    16. # 实际中通常使用更大的维度如32维, 64维.
    17. # 这里我们使用小的维度, 为了方便查看训练过程中权重的变化.
    18. EMBEDDING_DIM = 6
    19. HIDDEN_DIM = 6

    输出:

    创建模型:

    1. class LSTMTagger(nn.Module):
    3.     def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
    4.         super(LSTMTagger, self).__init__()
    5.         self.hidden_dim = hidden_dim
    7.         self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
    9.         # LSTM以word_embeddings作为输入, 输出维度为 hidden_dim 的隐藏状态值
    10.         self.lstm = nn.LSTM(embedding_dim, hidden_dim)
    11.         # 线性层将隐藏状态空间映射到标注空间
    12.         self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
    13.         self.hidden = self.init_hidden()
    15.     def init_hidden(self):
    16.         # 一开始并没有隐藏状态所以我们要先初始化一个
    17.         # 关于维度为什么这么设计请参考Pytoch相关文档
    18.         # 各个维度的含义是 (num_layers, minibatch_size, hidden_dim)
    19.         return (torch.zeros(1, 1, self.hidden_dim),
    20.                 torch.zeros(1, 1, self.hidden_dim))
    22.     def forward(self, sentence):
    23.         embeds = self.word_embeddings(sentence)
    24.         lstm_out, self.hidden = self.lstm(
    25.             embeds.view(len(sentence), 1, -1), self.hidden)
    26.         tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
    27.         tag_scores = F.log_softmax(tag_space, dim=1)
    28.         return tag_scores

    训练模型:

    输出:

    1. tensor([[-1.1389, -1.2024, -0.9693],
    2.         [-1.1065, -1.2200, -0.9834],
    3.         [-1.1286, -1.2093, -0.9726],
    4.         [-1.1190, -1.1960, -0.9916],
    5.         [-1.0137, -1.2642, -1.0366]])
    6. tensor([[-0.0858, -2.9355, -3.5374],
    7.         [-5.2313, -0.0234, -4.0314],
    8.         [-3.9098, -4.1279, -0.0368],
    10.         [-5.8170, -0.0183, -4.1879]])

    在上面的例子中, 每个词都有一个词嵌入, 作为序列模型的输入. 接下来让我们使用每个的单词的 字符级别的表达来增强词嵌入。 我们期望这个操作对结果能有显著提升, 因为像词缀这样的字符级 信息对于词性有很大的影响。比如说, 像包含词缀 -ly 的单词基本上都是被标注为副词.

    具体操作如下. 用c_w​的字符级表达, 同之前一样, 我们使用x_w​来表示词嵌入. 序列模型的输入就变成了x_w和c_w​的拼接. 因此, 如果 的维度x_w​是5, 的维度c_w​是3, 那么我们的 LSTM 网络的输入维度大小就是8.

    • 为了在字符级别上运行序列模型, 你需要用嵌入的字符来作为字符 LSTM 的输入。