烟台优化网站公司,公司域名注册后怎么建设网站,响应式网站适合优化吗,seo网站优化方案摘要这一章是循环神经网络#xff0c;太难了太难了#xff0c;有很多卡壳的地方理解了好久#xff0c;比如隐藏层和隐状态的区别、代码的含义#xff08;为此专门另写了一篇【笔记】记录对自主实现一个神经网络的步骤的理解#xff09;、梯度计算相关#xff08;【笔记】记录…这一章是循环神经网络太难了太难了有很多卡壳的地方理解了好久比如隐藏层和隐状态的区别、代码的含义为此专门另写了一篇【笔记】记录对自主实现一个神经网络的步骤的理解、梯度计算相关【笔记】记录对python中.grad()的一些理解。
第八章循环神经网络
8.1 序列模型
之前介绍了卷积神经网络了解了怎么将空间结构融入模型这一章的循环神经网络就是介绍如何将时间序列结构融入模型当中。
通常在一个有序列结构的模型预测中对于下一个时间步我们是按来预测的。
但是这样的话随着预测步数的推进复杂度会上升得非常快所以我们需要想出一些解决方法。
我们想出的方法自回归模型有两种
一种叫自回归模型是规定取预测步数之前的 个步数对当前预测步数进行预测也就是说不需要从 t 步取回第 1 步了只需要从t步取到第 t- 步。一种叫隐变量自回归模型是我们后面会一直介绍的方法将第 t 步之前步数的数据用一个隐状态 表示然后预测下一步 t1 时只要将 和 进行线性变化组合得到 再用 预测第 t1 步。 这一章初步实现了一个简单的自回归模型利用sin函数加一些随机误差生成数据再利用自回归模型进行训练预测。
内插法是根据现有数据预测单个步的数据预测数据来自现有数据。
外推法是根据现有数据不断推出后面的数据每步根据前几步预测出来的数据对未来进行预测。
实验结果表明内推法难度更小准确率也更高。而外推法得到的结果非常容易偏离正确值因为预测的错误容易“累计”不断预测非常容易偏离实际结果。
实验使用k步预测由k步之前的数据预测第k步的数据跨度为k实验结果表明随着k的增加错误会积累得越多预测质量急剧下降。
8.2 文本预处理
我们选取《时光机器》中的文本数据。
提取文本步骤包括
将文本作为字符串加载到内存中。将字符串拆分为词元建立词表将词元映射为数字索引将文本转换为数字索引
第1步
#save
d2l.DATA_HUB[time_machine] (d2l.DATA_URL timemachine.txt,090b5e7e70c295757f55df93cb0a180b9691891a)def read_time_machine(): #save将时间机器数据集加载到文本行的列表中with open(d2l.download(time_machine), r) as f:lines f.readlines()return [re.sub([^A-Za-z], , line).strip().lower() for line in lines]lines read_time_machine()
读取数据将除了字母以外的字符转为空格re.sub()正则匹配去除首位空格.strip()将大写转为小写.lower()
第2步
将文本行继续拆分为单个词元。
def tokenize(lines, tokenword): #save将文本行拆分为单词或字符词元if token word:return [line.split() for line in lines]elif token char:return [list(line) for line in lines]else:print(错误未知词元类型 token)tokens tokenize(lines)
for i in range(11):print(tokens[i])
这个函数实现了拆分单词和拆分字母两种方式默认拆分单词。
返回一些列表每个列表代表一行每一行有若干个单词或字母。
第3步
这一步要将词元构成字典的形式建立一个class类需要实现将输入的词元匹配上一个对应的数字索引。
class Vocab: #save文本词表def __init__(self, tokensNone, min_freq0, reserved_tokensNone):if tokens is None:tokens []if reserved_tokens is None:reserved_tokens []# 按出现频率排序counter count_corpus(tokens)self._token_freqs sorted(counter.items(), keylambda x: x[1],reverseTrue)# 未知词元的索引为0self.idx_to_token [unk] reserved_tokensself.token_to_idx {token: idxfor idx, token in enumerate(self.idx_to_token)}for token, freq in self._token_freqs:if freq min_freq:breakif token not in self.token_to_idx:self.idx_to_token.append(token)self.token_to_idx[token] len(self.idx_to_token) - 1def __len__(self):return len(self.idx_to_token)def __getitem__(self, tokens):if not isinstance(tokens, (list, tuple)):return self.token_to_idx.get(tokens, self.unk)return [self.__getitem__(token) for token in tokens]def to_tokens(self, indices):if not isinstance(indices, (list, tuple)):return self.idx_to_token[indices]return [self.idx_to_token[index] for index in indices]propertydef unk(self): # 未知词元的索引为0return 0propertydef token_freqs(self):return self._token_freqsdef count_corpus(tokens): #save统计词元的频率# 这里的tokens是1D列表或2D列表if len(tokens) 0 or isinstance(tokens[0], list):# 将词元列表展平成一个列表tokens [token for line in tokens for token in line]return collections.Counter(tokens)
这个类大概是根据词元出现的频率排序得出索引。
第4步
执行
vocab Vocab(tokens)
print(list(vocab.token_to_idx.items())[:10])
就可以得到 [(unk, 0), (the, 1), (i, 2), (and, 3), (of, 4), (a, 5), (to, 6), (was, 7), (in, 8), (that, 9)] 执行
for i in [0, 10]:print(文本:, tokens[i])print(索引:, vocab[tokens[i]])
就可以得到 文本: [the, time, machine, by, h, g, wells]
索引: [1, 19, 50, 40, 2183, 2184, 400]
文本: [twinkled, and, his, usually, pale, face, was, flushed, and, animated, the]
索引: [2186, 3, 25, 1044, 362, 113, 7, 1421, 3, 1045, 1] 整合以上功能
def load_corpus_time_machine(max_tokens-1): #save返回时光机器数据集的词元索引列表和词表lines read_time_machine()tokens tokenize(lines, char)vocab Vocab(tokens)# 因为时光机器数据集中的每个文本行不一定是一个句子或一个段落# 所以将所有文本行展平到一个列表中corpus [vocab[token] for line in tokens for token in line]if max_tokens 0:corpus corpus[:max_tokens]return corpus, vocabcorpus, vocab load_corpus_time_machine()
len(corpus), len(vocab)
加载数据切分为字母构造词典整合成一个大列表可选择是否取前max_tokens个字母。
8.3 语言模型和数据集
在构建模型之前我们要了解一些关于自然语言处理的相关知识。
基本概率规则比如 P(我想你) P(你|我,想)P(想|我)P(我) 为了得出一个句子的概率我们需要知道单词出现的概率以及单词在前几个单词出现的情况下出现的概率。
假设我们有一个非常大的语料库对于上面式子的条件概率我们可以通过 P(想|我) P(我想) / P(我) 得到。
但是对于一些不常见的组合语料库中出现的概率可能是零于是就要利用拉普拉斯平滑使所有语料库中没有出现过的组合概率不为零。
进行自然语言统计时我们将之前的数据中频率最高的词汇打印出来发现很多都是the、of、and之类的停用词并且前几个出现的概率比后面的概率要高很多。 打印出图像可以看出词频从某个临界点开始就下降得特别快。
这意味着单词频率符合齐鲁夫定律。
如果采用之前的平滑方法尾部数量就会大增。
我们再统计两个词汇组成的词组出现的频率、三个词汇组成的词组出现的频率 可以看出都是这种情况。
说明拉普拉斯平滑并不适合语言建模很多n元组很少出现所以我们使用深度学习模型。
我们读取长序列数据生成小批量数据作为特征然后移动生成它的标签。
1.随机抽样
def seq_data_iter_random(corpus, batch_size, num_steps): #save使用随机抽样生成一个小批量子序列# 从随机偏移量开始对序列进行分区随机范围包括num_steps-1corpus corpus[random.randint(0, num_steps - 1):]# 减去1是因为我们需要考虑标签num_subseqs (len(corpus) - 1) // num_steps# 长度为num_steps的子序列的起始索引initial_indices list(range(0, num_subseqs * num_steps, num_steps))# 在随机抽样的迭代过程中# 来自两个相邻的、随机的、小批量中的子序列不一定在原始序列上相邻random.shuffle(initial_indices)def data(pos):# 返回从pos位置开始的长度为num_steps的序列return corpus[pos: pos num_steps]num_batches num_subseqs // batch_sizefor i in range(0, batch_size * num_batches, batch_size):# 在这里initial_indices包含子序列的随机起始索引initial_indices_per_batch initial_indices[i: i batch_size]X [data(j) for j in initial_indices_per_batch]Y [data(j 1) for j in initial_indices_per_batch]yield np.array(X), np.array(Y)my_seq list(range(35))
for X, Y in seq_data_iter_random(my_seq, batch_size2, num_steps5):print(X: , X, \nY:, Y)
生成特征和标签 X: [[22. 23. 24. 25. 26.][27. 28. 29. 30. 31.]]
Y: [[23. 24. 25. 26. 27.][28. 29. 30. 31. 32.]]
X: [[ 7. 8. 9. 10. 11.][12. 13. 14. 15. 16.]]
Y: [[ 8. 9. 10. 11. 12.][13. 14. 15. 16. 17.]]
X: [[17. 18. 19. 20. 21.][ 2. 3. 4. 5. 6.]]
Y: [[18. 19. 20. 21. 22.][ 3. 4. 5. 6. 7.]] 2.顺序分区
def seq_data_iter_sequential(corpus, batch_size, num_steps): #save使用顺序分区生成一个小批量子序列# 从随机偏移量开始划分序列offset random.randint(0, num_steps)num_tokens ((len(corpus) - offset - 1) // batch_size) * batch_sizeXs np.array(corpus[offset: offset num_tokens])Ys np.array(corpus[offset 1: offset 1 num_tokens])Xs, Ys Xs.reshape(batch_size, -1), Ys.reshape(batch_size, -1)num_batches Xs.shape[1] // num_stepsfor i in range(0, num_steps * num_batches, num_steps):X Xs[:, i: i num_steps]Y Ys[:, i: i num_steps]yield X, Yfor X, Y in seq_data_iter_sequential(my_seq, batch_size2, num_steps5):print(X: , X, \nY:, Y)
生成特征和标签 X: [[ 0. 1. 2. 3. 4.][17. 18. 19. 20. 21.]]
Y: [[ 1. 2. 3. 4. 5.][18. 19. 20. 21. 22.]]
X: [[ 5. 6. 7. 8. 9.][22. 23. 24. 25. 26.]]
Y: [[ 6. 7. 8. 9. 10.][23. 24. 25. 26. 27.]]
X: [[10. 11. 12. 13. 14.][27. 28. 29. 30. 31.]]
Y: [[11. 12. 13. 14. 15.][28. 29. 30. 31. 32.]] 将两种方法打包
class SeqDataLoader: #save加载序列数据的迭代器def __init__(self, batch_size, num_steps, use_random_iter, max_tokens):if use_random_iter:self.data_iter_fn d2l.seq_data_iter_randomelse:self.data_iter_fn d2l.seq_data_iter_sequentialself.corpus, self.vocab d2l.load_corpus_time_machine(max_tokens)self.batch_size, self.num_steps batch_size, num_stepsdef __iter__(self):return self.data_iter_fn(self.corpus, self.batch_size, self.num_steps)
def load_data_time_machine(batch_size, num_steps, #saveuse_random_iterFalse, max_tokens10000):返回时光机器数据集的迭代器和词表data_iter SeqDataLoader(batch_size, num_steps, use_random_iter, max_tokens)return data_iter, data_iter.vocab
8.4 循环神经网络
循环神经网络将按照之前说的隐状态自回归模型每一步根据上一步的状态h和当前读取数据进行预测。 隐状态H的作用是保留前面步的历史信息相当于记忆一样。
这里书中提示了隐状态和隐藏层是不同的想了老半天为什么直到看到老师的ppt才懂 其实两者指的是差不多的东西只不过隐藏层是指那个层箭头而隐状态是指那个层输出的状态h。
没有隐状态就是普通神经网络输入x输出y中间的隐藏层不和前面的输入有关。
有隐状态就是隐藏层结合了前一个h输出的是隐状态h记录的前面的历史数据。
然后值得一提的是所有时间步是共享参数的也就是的计算和是类似的这使得循环神经网络的开销不会随着预测步数的增大而增大。
预测值y的计算如下 隐状态h的计算如下 循环神经网络对于每个批量比如you ar和它的标签ou are对每个小批量一个或多个字母执行上述计算操作这样就可以推出下一个字母如此反复。
由上述隐状态的公式可以看出我们可以将上一个隐状态和这一个输入横向合并物理将权重W纵向合并物理两者相乘加b得到的也是同样结果。
最后来看评判模型好坏的困惑度就是判断这个字母在这个位置出现的合理性概率可以用如下方法计算 累乘会导致数字过大或者过小于是将其取对数 这就是困惑度。最好情况为1最坏情况为正无穷大。
8.5 循环神经网络的从零开始实现
这一节单独放在【笔记】记录对自主实现一个神经网络的步骤的理解里了只需再介绍一个独热编码的实现
F.one_hot(torch.tensor([0, 2]), len(vocab))
对01两个数字独热编码长度为字母表长度。
运行结果是 tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0],[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0]]) 如果传入的是数组也可以给出对应独热编码结果上升一个维度。
8.6 循环神经网络的简洁实现
这一章我们构建一个隐藏单元为256的单隐藏层循环神经网络。
像之前那样读取数据
batch_size, num_steps 32, 35
train_iter, vocab d2l.load_data_time_machine(batch_size, num_steps)
定义模型
num_hiddens 256
rnn_layer nn.RNN(len(vocab), num_hiddens)
要注意的是nn.RNN不是整个循环神经网络而是只是隐藏层这部分输出的是隐藏层的预测数据我们还需要实现从隐状态到最后输出层的代码。
初始化隐状态
state torch.zeros((1, batch_size, num_hiddens))
state.shape
由于nn.RNN只包含隐藏层我们还需要建输出层并将两个层合并成一个完整的循环神经网络
#save
class RNNModel(nn.Module):循环神经网络模型def __init__(self, rnn_layer, vocab_size, **kwargs):super(RNNModel, self).__init__(**kwargs)self.rnn rnn_layerself.vocab_size vocab_sizeself.num_hiddens self.rnn.hidden_size# 如果RNN是双向的之后将介绍num_directions应该是2否则应该是1if not self.rnn.bidirectional:self.num_directions 1self.linear nn.Linear(self.num_hiddens, self.vocab_size)else:self.num_directions 2self.linear nn.Linear(self.num_hiddens * 2, self.vocab_size)def forward(self, inputs, state):X F.one_hot(inputs.T.long(), self.vocab_size)X X.to(torch.float32)Y, state self.rnn(X, state)# 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)# 它的输出形状是(时间步数*批量大小,词表大小)。output self.linear(Y.reshape((-1, Y.shape[-1])))return output, statedef begin_state(self, device, batch_size1):if not isinstance(self.rnn, nn.LSTM):# nn.GRU以张量作为隐状态return torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens),devicedevice)else:# nn.LSTM以元组作为隐状态return (torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens), devicedevice),torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens), devicedevice))
类接收一个隐藏层词汇表大小作为参数初始化传入参数并且设置线性层作为由隐状态到输出的函数。
前向传播连接两个函数先对输入进行独热编码然后依次放入隐藏层和线性层中计算输出输出为当前状态和当前输出。
begin_state函数初始化状态每次新一轮预测就调用这个函数。
实现完整个模型然后就可以将模型代入之前实现的预测和训练函数。
预测
device d2l.try_gpu()
net RNNModel(rnn_layer, vocab_sizelen(vocab))
net net.to(device)
d2l.predict_ch8(time traveller, 10, net, vocab, device)
训练
num_epochs, lr 500, 1
d2l.train_ch8(net, train_iter, vocab, lr, num_epochs, device)
8.7 通过时间反向传播
这一节分析了循环神经网络的梯度传播。 画出流程图可以看出越后面的步需要回溯越多这也是循环神经网络容易梯度爆炸和梯度消失的原因。
这一节主要是在用链式计算第t步的梯度公式。
