什么是网站解决方案,wordpress搭建ss,免费送的广告怎么在网站上做,咸阳做网站哪家好目录
一、数据集构建
1.1数据集的构建函数
1.2加载数据集并划分
1.3 构建Dataset类
二、模型构建
2.1嵌入层
2.2SRN层
2.3模型汇总
三、模型训练
3.1 训练指定长度的数字预测模型
3.2 损失曲线展示
四、模型评价
五、修改
附完整可运行代码
实验大体步骤#x…目录
一、数据集构建
1.1数据集的构建函数
1.2加载数据集并划分
1.3 构建Dataset类
二、模型构建
2.1嵌入层
2.2SRN层
2.3模型汇总
三、模型训练
3.1 训练指定长度的数字预测模型
3.2 损失曲线展示
四、模型评价
五、修改
附完整可运行代码
实验大体步骤 简单循环网络在参数学习时存在长程依赖问题很难建模长时间间隔Long Range的状态之间的依赖关系。为了测试简单循环网络的记忆能力本节构建一个数字求和任务进行实验。
数字求和任务的输入是一串数字前两个位置的数字为0-9其余数字随机生成主要为0预测目标是输入序列中前两个数字的加和。下图展示了长度为10的数字序列 如果序列长度越长准确率越高则说明网络的记忆能力越好因此我们可以构建不同长度的数据集通过验证简单循环网络在不同长度的数据集上的表现从而测试简单循环网络的长程依赖能力.
一、数据集构建
我们首先构建不同长度的数字预测数据集DigitSum.
由于在本任务中输入序列的前两位数字为 0 − 9其组合数是固定的所以可以穷举所有的前两位数字组合并在后面默认用0填充到固定长度. 但考虑到数据的多样性这里对生成的数字序列中的零位置进行随机采样并将其随机替换成0-9的数字以增加样本的数量
我们可以通过设置kk的数值来指定一条样本随机生成的数字序列数量.当生成某个指定长度的数据集时会同时生成训练集、验证集和测试集。当k3时生成训练集。当kk1时生成验证集和测试集.
1.1数据集的构建函数
代码如下
import os
import random
import numpy as np
from torch import nn# 固定随机种子
random.seed(0)
np.random.seed(0)# 数据集构建
def generate_data(length, k, save_path):if length 3:raise ValueError(The length of data should be greater than 2.)if k 0:raise ValueError(k should be greater than 0.)# 创建目录如果不存在directory os.path.dirname(save_path)if not os.path.exists(directory):os.makedirs(directory)# 生成100条长度为length的数字序列除前两个字符外序列其余数字暂用0填充base_examples []for n1 in range(0, 10):for n2 in range(0, 10):seq [n1, n2] [0] * (length - 2)label n1 n2base_examples.append((seq, label))examples []# 数据增强对base_examples中的每条数据默认生成k条数据放入examplesfor base_example in base_examples:for _ in range(k):# 随机生成替换的元素位置和元素idx np.random.randint(2, length)val np.random.randint(0, 10)# 对序列中的对应零元素进行替换seq base_example[0].copy()label base_example[1]seq[idx] valexamples.append((seq, label))# 保存增强后的数据with open(save_path, w, encodingutf-8) as f:for example in examples:# 将数据转为字符串类型方便保存seq [str(e) for e in example[0]]label str(example[1])line .join(seq) \t label \nf.write(line)print(fgenerate data to: {save_path}.)# 定义生成的数字序列长度
lengths [5, 10, 15, 20, 25, 30, 35]
for length in lengths:# 生成长度为length的训练数据save_path f./datasets/{length}/train.txtk 3generate_data(length, k, save_path)# 生成长度为length的验证数据save_path f./datasets/{length}/dev.txtk 1generate_data(length, k, save_path)# 生成长度为length的测试数据save_path f./datasets/{length}/test.txtk 1generate_data(length, k, save_path)1.2加载数据集并划分
本实验提前生成了长度分别为5、10、 15、20、25、30和35的7份数据存放于“./datasets”目录下
代码如下
# 加载数据并进行数据划分
def load_data(data_path):# 加载训练集train_examples []train_path os.path.join(data_path, train.txt)with open(train_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])train_examples.append((seq, label))# 加载验证集dev_examples []dev_path os.path.join(data_path, dev.txt)with open(dev_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])dev_examples.append((seq, label))# 加载测试集test_examples []test_path os.path.join(data_path, test.txt)with open(test_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])test_examples.append((seq, label))return train_examples, dev_examples, test_examples# 设定加载的数据集的长度
length 5
# 该长度的数据集的存放目录
data_path f./datasets/{length}
# 加载该数据集
train_examples, dev_examples, test_examples load_data(data_path)
print(dev example:, dev_examples[:2])
print(训练集数量, len(train_examples))
print(验证集数量, len(dev_examples))
print(测试集数量, len(test_examples))运行结果 1.3 构建Dataset类
代码如下
# 构造Dataset类
from torch.utils.data import Dataset, DataLoader
import torchclass DigitSumDataset(Dataset):def __init__(self, data):self.data datadef __getitem__(self, idx):example self.data[idx]seq torch.tensor(example[0], dtypetorch.int64)label torch.tensor(example[1], dtypetorch.int64)return seq, labeldef __len__(self):return len(self.data)二、模型构建 整个模型由以下几个部分组成
1 嵌入层将输入的数字序列进行向量化即将每个数字映射为向量
2 SRN 层接收向量序列更新循环单元将最后时刻的隐状态作为整个序列的表示
3 输出层一个线性层输出分类的结果.
2.1嵌入层
本任务输入的样本是数字序列为了更好地表示数字需要将数字映射为一个嵌入Embedding向量。嵌入向量中的每个维度均能用来刻画该数字本身的某种特性。由于向量能够表达该数字更多的信息利用向量进行数字求和任务可以使得模型具有更强的拟合能力。 代码如下
# 嵌入层
class Embedding(nn.Module):def __init__(self, num_embeddings, embedding_dim):super(Embedding, self).__init__()self.W nn.init.xavier_uniform_(torch.empty(num_embeddings, embedding_dim), gain1.0)def forward(self, inputs):# 根据索引获取对应词向量embs self.W[inputs]return embsemb_layer Embedding(10, 5)
inputs torch.tensor([0, 1, 2, 3])
emb_layer(inputs)思考如果不使用嵌入层直接将数字作为SRN层输入有什么问题 ①神经网络尤其是递归神经网络RNN通常期望接收连续的输入数据。数字例如0, 1, 2, 3, 等是离散的它们与模型期望的输入方式不太匹配。如果直接将数字作为输入模型可能难以理解数字之间的相对关系。模型可能会将数字 1 和 2 看作两个独立的、无关的输入无法理解它们之间的顺序和数值差异。 ②数字 100 可能和数字 1 在输入层上的表示差异非常大而这种差异不一定反映了数字之间的实际关系。在神经网络中输入特征的尺度差异可能导致模型训练不稳定且难以收敛。 2.2SRN层
代码如下
# SRN层
import torch
import torch.nn as nn
import torch.nn.functional as Ftorch.manual_seed(0)# SRN模型
class SRN(nn.Module):def __init__(self, input_size, hidden_size, W_attrNone, U_attrNone, b_attrNone):super(SRN, self).__init__()# 嵌入向量的维度self.input_size input_size# 隐状态的维度self.hidden_size hidden_size# 定义模型参数W其shape为 input_size x hidden_sizeif W_attr None:W torch.zeros(size[input_size, hidden_size], dtypetorch.float32)else:W torch.tensor(W_attr, dtypetorch.float32)self.W torch.nn.Parameter(W)# 定义模型参数U其shape为hidden_size x hidden_sizeif U_attr None:U torch.zeros(size[hidden_size, hidden_size], dtypetorch.float32)else:U torch.tensor(U_attr, dtypetorch.float32)self.U torch.nn.Parameter(U)# 定义模型参数b其shape为 1 x hidden_sizeif b_attr None:b torch.zeros(size[1, hidden_size], dtypetorch.float32)else:b torch.tensor(b_attr, dtypetorch.float32)self.b torch.nn.Parameter(b)# 初始化向量def init_state(self, batch_size):hidden_state torch.zeros(size[batch_size, self.hidden_size], dtypetorch.float32)return hidden_state# 定义前向计算def forward(self, inputs, hidden_stateNone):# inputs: 输入数据, 其shape为batch_size x seq_len x input_sizebatch_size, seq_len, input_size inputs.shape# 初始化起始状态的隐向量, 其shape为 batch_size x hidden_sizeif hidden_state is None:hidden_state self.init_state(batch_size)# 循环执行RNN计算for step in range(seq_len):# 获取当前时刻的输入数据step_input, 其shape为 batch_size x input_sizestep_input inputs[:, step, :]# 获取当前时刻的隐状态向量hidden_state, 其shape为 batch_size x hidden_size# hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)hidden_state hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)return hidden_state# 初始化参数并运行
U_attr [[0.0, 0.1], [0.1, 0.0]]
b_attr [[0.1, 0.1]]
W_attr [[0.1, 0.2], [0.1, 0.2]]srn SRN(2, 2, W_attrW_attr, U_attrU_attr, b_attrb_attr)inputs torch.tensor([[[1, 0], [0, 2]]], dtypetorch.float32)
hidden_state srn(inputs)
print(hidden_state, hidden_state)运行结果如下 PyTorch框架内置了SRN的API torch.nn.RNN
代码如下
# PyTorch框架内置了SRN的API torch.nn.RNN
# 初始化参数并运行
U_attr [[0.0, 0.1], [0.1, 0.0]]
b_attr [[0.1, 0.1]]
W_attr [[0.1, 0.2], [0.1, 0.2]]srn SRN(2, 2, W_attrW_attr, U_attrU_attr, b_attrb_attr)inputs torch.tensor([[[1, 0], [0, 2]]], dtypetorch.float32)
hidden_state srn(inputs)
print(hidden_state, hidden_state)# 将自己实现的SRN和PyTorch框架内置的RNN返回的结果进行打印展示
# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size 8, 20, 32
inputs torch.randn([batch_size, seq_len, input_size])# 设置模型的hidden_size
hidden_size 32
torch_srn nn.RNN(input_size, hidden_size)
self_srn SRN(input_size, hidden_size)self_hidden_state self_srn(inputs)
torch_outputs, torch_hidden_state torch_srn(inputs)print(self_srn hidden_state: , self_hidden_state.shape)
print(torch_srn outpus:, torch_outputs.shape)
print(torch_srn hidden_state:, torch_hidden_state.shape)
运行结果 将自己实现的SRN和PyTorch框架内置的RNN返回的结果进行打印展示
# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size, hidden_size 2, 5, 10, 10
inputs torch.randn([batch_size, seq_len, input_size])# 设置模型的hidden_sizetorch_srn nn.RNN(input_size, hidden_size, biasFalse)# 获取torch_srn中的参数并设置相应的paramAttr,用于初始化SRN
W_attr torch_srn.weight_ih_l0.T
U_attr torch_srn.weight_hh_l0.T
self_srn SRN(input_size, hidden_size, W_attrW_attr, U_attrU_attr)# 进行前向计算获取隐状态向量并打印展示
self_hidden_state self_srn(inputs)
torch_outputs, torch_hidden_state torch_srn(inputs)
print(torch SRN:\n, torch_hidden_state.detach().numpy().squeeze(0))
print(self SRN:\n, self_hidden_state.detach().numpy())
运行结果如下 对比一下运行时间
# 两者时间差异
import time# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size, hidden_size 2, 5, 10, 10
inputs torch.randn([batch_size, seq_len, input_size])# 实例化模型
self_srn SRN(input_size, hidden_size)
torch_srn nn.RNN(input_size, hidden_size)# 计算自己实现的SRN运算速度
model_time 0
for i in range(100):strat_time time.time()out self_srn(inputs)if i 10:continueend_time time.time()model_time (end_time - strat_time)
avg_model_time model_time / 90
print(self_srn speed:, avg_model_time, s)# 计算torch内置的SRN运算速度
model_time 0
for i in range(100):strat_time time.time()out torch_srn(inputs)# 预热10次运算不计入最终速度统计if i 10:continueend_time time.time()model_time (end_time - strat_time)
avg_model_time model_time / 90
print(torch_srn speed:, avg_model_time, s)
运行结果 我看着感觉是两者并没有差太多。
2.3模型汇总
在定义了每一层的算子之后我们定义一个数字求和模型Model_RNN4SeqClass该模型会将嵌入层、SRN层和线性层进行组合以实现数字求和的功能.
具体来讲Model_RNN4SeqClass会接收一个SRN层实例用于处理数字序列数据同时在__init__函数中定义一个Embedding嵌入层其会将输入的数字作为索引输出对应的向量最后会使用paddle.nn.Linear定义一个线性层。
代码如下
# 模型汇总
# 基于RNN实现数字预测的模型
class Model_RNN4SeqClass(nn.Module):def __init__(self, model, num_digits, input_size, hidden_size, num_classes):super(Model_RNN4SeqClass, self).__init__()# 传入实例化的RNN层例如SRNself.rnn_model model# 词典大小self.num_digits num_digits# 嵌入向量的维度self.input_size input_size# 定义Embedding层self.embedding Embedding(num_digits, input_size)# 定义线性层self.linear nn.Linear(hidden_size, num_classes)def forward(self, inputs):# 将数字序列映射为相应向量inputs_emb self.embedding(inputs)# 调用RNN模型hidden_state self.rnn_model(inputs_emb)# 使用最后一个时刻的状态进行数字预测logits self.linear(hidden_state)return logits# 实例化一个input_size为4 hidden_size为5的SRN
srn SRN(4, 5)
# 基于srn实例化一个数字预测模型实例
model Model_RNN4SeqClass(srn, 10, 4, 5, 19)
# 生成一个shape为 2 x 3 的批次数据
inputs torch.tensor([[1, 2, 3], [2, 3, 4]])
# 进行模型前向预测
logits model(inputs)
print(logits)
运行结果 三、模型训练
3.1 训练指定长度的数字预测模型
代码如下
# 模型训练
import os
import random
import torch
import numpy as np
from nndl_3 import Accuracy, RunnerV3# 训练轮次
num_epochs 500
# 学习率
lr 0.0001
# 输入数字的类别数
num_digits 10
# 将数字映射为向量的维度
input_size 32
# 隐状态向量的维度
hidden_size 32
# 预测数字的类别数
num_classes 19
# 批大小
batch_size 8
# 模型保存目录
save_dir ./checkpoints# 通过指定length进行不同长度数据的实验
def train(length):print(f\n Training SRN with data of length {length}.)# 加载长度为length的数据data_path f./datasets/{length}train_examples, dev_examples, test_examples load_data(data_path)train_set, dev_set, test_set DigitSumDataset(train_examples), DigitSumDataset(dev_examples), DigitSumDataset(test_examples)train_loader DataLoader(train_set, batch_sizebatch_size)dev_loader DataLoader(dev_set, batch_sizebatch_size)test_loader DataLoader(test_set, batch_sizebatch_size)# 实例化模型base_model SRN(input_size, hidden_size)model Model_RNN4SeqClass(base_model, num_digits, input_size, hidden_size, num_classes)# 指定优化器optimizer torch.optim.Adam(lrlr, paramsmodel.parameters())# 定义评价指标metric Accuracy()# 定义损失函数loss_fn nn.CrossEntropyLoss()# 基于以上组件实例化Runnerrunner RunnerV3(model, optimizer, loss_fn, metric)# 进行模型训练model_save_path os.path.join(save_dir, fbest_srn_model_{length}.pdparams)runner.train(train_loader, dev_loader, num_epochsnum_epochs, eval_steps100, log_steps100,save_pathmodel_save_path)return runnersrn_runners {}# 多组训练
lengths [10, 15, 20, 25, 30, 35]
for length in lengths:runner train(length)srn_runners[length] runner3.2 损失曲线展示
代码如下
# 损失函数绘制
import matplotlib.pyplot as plt
def plot_training_loss(runner, fig_name, sample_step):plt.figure()train_items runner.train_step_losses[::sample_step]train_steps [x[0] for x in train_items]train_losses [x[1] for x in train_items]plt.plot(train_steps, train_losses, color#e4007f, labelTrain loss)dev_steps [x[0] for x in runner.dev_losses]dev_losses [x[1] for x in runner.dev_losses]plt.plot(dev_steps, dev_losses, color#f19ec2, linestyle--, labelDev loss)# 绘制坐标轴和图例plt.ylabel(loss, fontsizelarge)plt.xlabel(step, fontsizelarge)plt.legend(locupper right, fontsizex-large)plt.savefig(fig_name)plt.show()# 画出训练过程中的损失图
for length in lengths:runner srn_runners[length]fig_name f./images/6.6_{length}.pdfplot_training_loss(runner, fig_name, sample_step100)运行结果分别是长度为10、15、20、25、30、35lr0.001的情况 可以发现是有点过拟合的Train loss不断减小但是dev loss却在上升。 这表明当序列变长时SRN模型保持序列长期依赖能力在逐渐变弱越来越无法学习到有用的知识。SRN模型过拟合到序列结尾的信息而遗忘了序列开始位置的信息。说明SRN模型在建模长程依赖方面的能力比较弱。 四、模型评价
代码如下
# 模型评价
srn_dev_scores []
srn_test_scores []
for length in lengths:print(fEvaluate SRN with data length {length}.)runner srn_runners[length]# 加载训练过程中效果最好的模型model_path os.path.join(save_dir, fbest_srn_model_{length}.pdparams)runner.load_model(model_path)# 加载长度为length的数据data_path f./datasets/{length}train_examples, dev_examples, test_examples load_data(data_path)test_set DigitSumDataset(test_examples)test_loader DataLoader(test_set, batch_sizebatch_size)# 使用测试集评价模型获取测试集上的预测准确率score, _ runner.evaluate(test_loader)srn_test_scores.append(score)srn_dev_scores.append(max(runner.dev_scores))for length, dev_score, test_score in zip(lengths, srn_dev_scores, srn_test_scores):print(f[SRN] length:{length}, dev_score: {dev_score}, test_score: {test_score: .5f})# 将SRN在不同长度的验证集和测试集数据上的表现绘制成图片进行观察
import matplotlib.pyplot as pltplt.plot(lengths, srn_dev_scores, -o, color#e4007f, labelDev Accuracy)
plt.plot(lengths, srn_test_scores, -o, color#f19ec2, labelTest Accuracy)# 绘制坐标轴和图例
plt.ylabel(accuracy, fontsizelarge)
plt.xlabel(sequence length, fontsizelarge)
plt.legend(locupper right, fontsizex-large)fig_name ./images/6.7.pdf
plt.savefig(fig_name)
plt.show()运行结果 可以看出实验结果并不是很好。
五、修改
于是参看书上的动手练习6.1
参考《神经网络与深度学习》中的公式(6.50)改进SRN的循环单元加入隐状态之间的残差连接并重复数字求和实验。观察是否可以缓解长程依赖问题。 这样和之间为既有线性关系也有非线性关系并且可以缓解梯度消失问题于是尝试加入残差连接并重新进行实验。根据这个公式可知只需要将原来的hidden_state加上上一个时刻的hidden_state即可。
原始代码 hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)修改为 hidden_state hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)运行结果 从以上的loss图可以看出train的loss基本和dev的loss重合减轻了过拟合。
但是这种改进方法还存在着两个问题 于是可以通过引入门控机制来进一步改进模型也就是LSTM。 造成简单循环网络较难建模长程依赖问题的原因有两个梯度爆炸和梯度消失。 一般来讲循环网络的梯度爆炸问题比较容易解决一般通过权重衰减或梯度截断可以较好地来避免对于梯度消失问题更加有效的方式是改变模型比如通过长短期记忆网络LSTM来进行缓解。 各个长度数据集的准确率可以看出并不是长度越长准确率越低往往在25或者30处存在一个拐点中点低两边高或者是中间高两边低那这种情况是为什么呢 查阅了一下资料做出的一些解释可能有点不太准确 ①网络的训练时间对准确率也有影响。较长的序列需要更多的训练时间来优化网络参数且较长序列可能更容易陷入局部最优解。30长度的序列可能正好处于训练过程中较难收敛的区间而25和35的序列可能更容易收敛到较好的解。 ②在较短的序列的情况下网络可能会过拟合或过于依赖序列中的少量信息网络可能会过度“记住”某些样本的特征而不是学习到更通用的规律。随着数据集长度增加网络获得的信息变得更加冗余可以帮助它做出更泛化的预测。过短的序列会使模型过度依赖训练集中的特定样本而较长的序列可以让网络更好地学习到前两个数字的关系避免过拟合。从图xlen25的loss也可以看出他的train loss和dev loss相差最多也说明了为什么len25是准确率最低的情况。 调了调学习率
lr0.01 lr0.1
这个也太不好了吧
lr0.0001 这个就感觉有点欠拟合的意思了。 我发现SRN的准确率不宜调的过大当lr0.001时所有长度数据集准确率基本都在0.8以上但是lr0.01和0.1时准确率就不是很好看了。所以较长的序列可能需要更低的学习率或更高的隐藏层单元数。如果超参数设置不合理可能会导致模型在某些长度下的性能波动。 但是从lr0.0001的图中可以看出过小的准确率也不是很好train和dev的loss都在逐渐减小但是可能还没有训练好产生了欠拟合所以出现了len35比任何长度的准确率都高的情况。 思考题如果不使用嵌入层直接将数字作为SRN层输入有什么问题 ①神经网络尤其是递归神经网络RNN通常期望接收连续的输入数据。数字例如0, 1, 2, 3, 等是离散的它们与模型期望的输入方式不太匹配。如果直接将数字作为输入模型可能难以理解数字之间的相对关系。模型可能会将数字 1 和 2 看作两个独立的、无关的输入无法理解它们之间的顺序和数值差异。 ②数字 100 可能和数字 1 在输入层上的表示差异非常大而这种差异不一定反映了数字之间的实际关系。在神经网络中输入特征的尺度差异可能导致模型训练不稳定且难以收敛。 什么是词向量呢 之前讲过的word2vec是词向量的一种方式。词向量是一种将词汇映射为固定长度连续向量的技术每个词被映射成一个固定维度的向量通常是几十到几百维。在一个好的词向量空间中语义相似的词会有相似的向量表示。例如“猫”和“狗”的词向量应该比“猫”和“汽车”的词向量更相似。同时通过词向量还可以捕捉词汇之间的语义关系如“国王” - “男人” “女人” ≈ “女王” 附完整可运行代码
主程序
import os
import random
import numpy as np
from torch import nn# 固定随机种子
random.seed(0)
np.random.seed(0)# 数据集构建
def generate_data(length, k, save_path):if length 3:raise ValueError(The length of data should be greater than 2.)if k 0:raise ValueError(k should be greater than 0.)# 创建目录如果不存在directory os.path.dirname(save_path)if not os.path.exists(directory):os.makedirs(directory)# 生成100条长度为length的数字序列除前两个字符外序列其余数字暂用0填充base_examples []for n1 in range(0, 10):for n2 in range(0, 10):seq [n1, n2] [0] * (length - 2)label n1 n2base_examples.append((seq, label))examples []# 数据增强对base_examples中的每条数据默认生成k条数据放入examplesfor base_example in base_examples:for _ in range(k):# 随机生成替换的元素位置和元素idx np.random.randint(2, length)val np.random.randint(0, 10)# 对序列中的对应零元素进行替换seq base_example[0].copy()label base_example[1]seq[idx] valexamples.append((seq, label))# 保存增强后的数据with open(save_path, w, encodingutf-8) as f:for example in examples:# 将数据转为字符串类型方便保存seq [str(e) for e in example[0]]label str(example[1])line .join(seq) \t label \nf.write(line)print(fgenerate data to: {save_path}.)# 定义生成的数字序列长度
lengths [5, 10, 15, 20, 25, 30, 35]
for length in lengths:# 生成长度为length的训练数据save_path f./datasets/{length}/train.txtk 3generate_data(length, k, save_path)# 生成长度为length的验证数据save_path f./datasets/{length}/dev.txtk 1generate_data(length, k, save_path)# 生成长度为length的测试数据save_path f./datasets/{length}/test.txtk 1generate_data(length, k, save_path)# 加载数据并进行数据划分
def load_data(data_path):# 加载训练集train_examples []train_path os.path.join(data_path, train.txt)with open(train_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])train_examples.append((seq, label))# 加载验证集dev_examples []dev_path os.path.join(data_path, dev.txt)with open(dev_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])dev_examples.append((seq, label))# 加载测试集test_examples []test_path os.path.join(data_path, test.txt)with open(test_path, r, encodingutf-8) as f:for line in f.readlines():# 解析一行数据将其处理为数字序列seq和标签labelitems line.strip().split(\t)seq [int(i) for i in items[0].split( )]label int(items[1])test_examples.append((seq, label))return train_examples, dev_examples, test_examples# 设定加载的数据集的长度
length 5
# 该长度的数据集的存放目录
data_path f./datasets/{length}
# 加载该数据集
train_examples, dev_examples, test_examples load_data(data_path)
print(dev example:, dev_examples[:2])
print(训练集数量, len(train_examples))
print(验证集数量, len(dev_examples))
print(测试集数量, len(test_examples))# 构造Dataset类
from torch.utils.data import Dataset, DataLoader
import torchclass DigitSumDataset(Dataset):def __init__(self, data):self.data datadef __getitem__(self, idx):example self.data[idx]seq torch.tensor(example[0], dtypetorch.int64)label torch.tensor(example[1], dtypetorch.int64)return seq, labeldef __len__(self):return len(self.data)# 嵌入层
class Embedding(nn.Module):def __init__(self, num_embeddings, embedding_dim):super(Embedding, self).__init__()self.W nn.init.xavier_uniform_(torch.empty(num_embeddings, embedding_dim), gain1.0)def forward(self, inputs):# 根据索引获取对应词向量embs self.W[inputs]return embsemb_layer Embedding(10, 5)
inputs torch.tensor([0, 1, 2, 3])
emb_layer(inputs)# SRN层
import torch
import torch.nn as nn
import torch.nn.functional as Ftorch.manual_seed(0)# SRN模型
class SRN(nn.Module):def __init__(self, input_size, hidden_size, W_attrNone, U_attrNone, b_attrNone):super(SRN, self).__init__()# 嵌入向量的维度self.input_size input_size# 隐状态的维度self.hidden_size hidden_size# 定义模型参数W其shape为 input_size x hidden_sizeif W_attr None:W torch.zeros(size[input_size, hidden_size], dtypetorch.float32)else:W torch.tensor(W_attr, dtypetorch.float32)self.W torch.nn.Parameter(W)# 定义模型参数U其shape为hidden_size x hidden_sizeif U_attr None:U torch.zeros(size[hidden_size, hidden_size], dtypetorch.float32)else:U torch.tensor(U_attr, dtypetorch.float32)self.U torch.nn.Parameter(U)# 定义模型参数b其shape为 1 x hidden_sizeif b_attr None:b torch.zeros(size[1, hidden_size], dtypetorch.float32)else:b torch.tensor(b_attr, dtypetorch.float32)self.b torch.nn.Parameter(b)# 初始化向量def init_state(self, batch_size):hidden_state torch.zeros(size[batch_size, self.hidden_size], dtypetorch.float32)return hidden_state# 定义前向计算def forward(self, inputs, hidden_stateNone):# inputs: 输入数据, 其shape为batch_size x seq_len x input_sizebatch_size, seq_len, input_size inputs.shape# 初始化起始状态的隐向量, 其shape为 batch_size x hidden_sizeif hidden_state is None:hidden_state self.init_state(batch_size)# 循环执行RNN计算for step in range(seq_len):# 获取当前时刻的输入数据step_input, 其shape为 batch_size x input_sizestep_input inputs[:, step, :]# 获取当前时刻的隐状态向量hidden_state, 其shape为 batch_size x hidden_size# hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)hidden_state hidden_state F.tanh(torch.matmul(step_input, self.W) torch.matmul(hidden_state, self.U) self.b)return hidden_state# 初始化参数并运行
U_attr [[0.0, 0.1], [0.1, 0.0]]
b_attr [[0.1, 0.1]]
W_attr [[0.1, 0.2], [0.1, 0.2]]srn SRN(2, 2, W_attrW_attr, U_attrU_attr, b_attrb_attr)inputs torch.tensor([[[1, 0], [0, 2]]], dtypetorch.float32)
hidden_state srn(inputs)
print(hidden_state, hidden_state)# PyTorch框架内置了SRN的API torch.nn.RNN
# 初始化参数并运行
U_attr [[0.0, 0.1], [0.1, 0.0]]
b_attr [[0.1, 0.1]]
W_attr [[0.1, 0.2], [0.1, 0.2]]srn SRN(2, 2, W_attrW_attr, U_attrU_attr, b_attrb_attr)inputs torch.tensor([[[1, 0], [0, 2]]], dtypetorch.float32)
hidden_state srn(inputs)
print(hidden_state, hidden_state)# 将自己实现的SRN和PyTorch框架内置的RNN返回的结果进行打印展示
# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size 8, 20, 32
inputs torch.randn([batch_size, seq_len, input_size])# 设置模型的hidden_size
hidden_size 32
torch_srn nn.RNN(input_size, hidden_size)
self_srn SRN(input_size, hidden_size)self_hidden_state self_srn(inputs)
torch_outputs, torch_hidden_state torch_srn(inputs)print(self_srn hidden_state: , self_hidden_state.shape)
print(torch_srn outpus:, torch_outputs.shape)
print(torch_srn hidden_state:, torch_hidden_state.shape)# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size, hidden_size 2, 5, 10, 10
inputs torch.randn([batch_size, seq_len, input_size])# 设置模型的hidden_sizetorch_srn nn.RNN(input_size, hidden_size, biasFalse)# 获取torch_srn中的参数并设置相应的paramAttr,用于初始化SRN
W_attr torch_srn.weight_ih_l0.T
U_attr torch_srn.weight_hh_l0.T
self_srn SRN(input_size, hidden_size, W_attrW_attr, U_attrU_attr)# 进行前向计算获取隐状态向量并打印展示
self_hidden_state self_srn(inputs)
torch_outputs, torch_hidden_state torch_srn(inputs)
print(torch SRN:\n, torch_hidden_state.detach().numpy().squeeze(0))
print(self SRN:\n, self_hidden_state.detach().numpy())# 两者时间差异
import time# 这里创建一个随机数组作为测试数据数据shape为batch_size x seq_len x input_size
batch_size, seq_len, input_size, hidden_size 2, 5, 10, 10
inputs torch.randn([batch_size, seq_len, input_size])# 实例化模型
self_srn SRN(input_size, hidden_size)
torch_srn nn.RNN(input_size, hidden_size)# 计算自己实现的SRN运算速度
model_time 0
for i in range(100):strat_time time.time()out self_srn(inputs)if i 10:continueend_time time.time()model_time (end_time - strat_time)
avg_model_time model_time / 90
print(self_srn speed:, avg_model_time, s)# 计算torch内置的SRN运算速度
model_time 0
for i in range(100):strat_time time.time()out torch_srn(inputs)# 预热10次运算不计入最终速度统计if i 10:continueend_time time.time()model_time (end_time - strat_time)
avg_model_time model_time / 90
print(torch_srn speed:, avg_model_time, s)# 模型汇总
# 基于RNN实现数字预测的模型
class Model_RNN4SeqClass(nn.Module):def __init__(self, model, num_digits, input_size, hidden_size, num_classes):super(Model_RNN4SeqClass, self).__init__()# 传入实例化的RNN层例如SRNself.rnn_model model# 词典大小self.num_digits num_digits# 嵌入向量的维度self.input_size input_size# 定义Embedding层self.embedding Embedding(num_digits, input_size)# 定义线性层self.linear nn.Linear(hidden_size, num_classes)def forward(self, inputs):# 将数字序列映射为相应向量inputs_emb self.embedding(inputs)# 调用RNN模型hidden_state self.rnn_model(inputs_emb)# 使用最后一个时刻的状态进行数字预测logits self.linear(hidden_state)return logits# 实例化一个input_size为4 hidden_size为5的SRN
srn SRN(4, 5)
# 基于srn实例化一个数字预测模型实例
model Model_RNN4SeqClass(srn, 10, 4, 5, 19)
# 生成一个shape为 2 x 3 的批次数据
inputs torch.tensor([[1, 2, 3], [2, 3, 4]])
# 进行模型前向预测
logits model(inputs)
print(logits)# 模型训练
import os
import random
import torch
import numpy as np
from nndl_3 import Accuracy, RunnerV3# 训练轮次
num_epochs 500
# 学习率
lr 0.0001
# 输入数字的类别数
num_digits 10
# 将数字映射为向量的维度
input_size 32
# 隐状态向量的维度
hidden_size 32
# 预测数字的类别数
num_classes 19
# 批大小
batch_size 8
# 模型保存目录
save_dir ./checkpoints# 通过指定length进行不同长度数据的实验
def train(length):print(f\n Training SRN with data of length {length}.)# 加载长度为length的数据data_path f./datasets/{length}train_examples, dev_examples, test_examples load_data(data_path)train_set, dev_set, test_set DigitSumDataset(train_examples), DigitSumDataset(dev_examples), DigitSumDataset(test_examples)train_loader DataLoader(train_set, batch_sizebatch_size)dev_loader DataLoader(dev_set, batch_sizebatch_size)test_loader DataLoader(test_set, batch_sizebatch_size)# 实例化模型base_model SRN(input_size, hidden_size)model Model_RNN4SeqClass(base_model, num_digits, input_size, hidden_size, num_classes)# 指定优化器optimizer torch.optim.Adam(lrlr, paramsmodel.parameters())# 定义评价指标metric Accuracy()# 定义损失函数loss_fn nn.CrossEntropyLoss()# 基于以上组件实例化Runnerrunner RunnerV3(model, optimizer, loss_fn, metric)# 进行模型训练model_save_path os.path.join(save_dir, fbest_srn_model_{length}.pdparams)runner.train(train_loader, dev_loader, num_epochsnum_epochs, eval_steps100, log_steps100,save_pathmodel_save_path)return runnersrn_runners {}# 多组训练
lengths [10, 15, 20, 25, 30, 35]
for length in lengths:runner train(length)srn_runners[length] runner# 损失函数绘制
import matplotlib.pyplot as plt
def plot_training_loss(runner, fig_name, sample_step):plt.figure()train_items runner.train_step_losses[::sample_step]train_steps [x[0] for x in train_items]train_losses [x[1] for x in train_items]plt.plot(train_steps, train_losses, color#e4007f, labelTrain loss)dev_steps [x[0] for x in runner.dev_losses]dev_losses [x[1] for x in runner.dev_losses]plt.plot(dev_steps, dev_losses, color#f19ec2, linestyle--, labelDev loss)# 绘制坐标轴和图例plt.ylabel(loss, fontsizelarge)plt.xlabel(step, fontsizelarge)plt.legend(locupper right, fontsizex-large)plt.savefig(fig_name)plt.show()# 画出训练过程中的损失图
for length in lengths:runner srn_runners[length]fig_name f./images/6.6_{length}.pdfplot_training_loss(runner, fig_name, sample_step100)# 模型评价
srn_dev_scores []
srn_test_scores []
for length in lengths:print(fEvaluate SRN with data length {length}.)runner srn_runners[length]# 加载训练过程中效果最好的模型model_path os.path.join(save_dir, fbest_srn_model_{length}.pdparams)runner.load_model(model_path)# 加载长度为length的数据data_path f./datasets/{length}train_examples, dev_examples, test_examples load_data(data_path)test_set DigitSumDataset(test_examples)test_loader DataLoader(test_set, batch_sizebatch_size)# 使用测试集评价模型获取测试集上的预测准确率score, _ runner.evaluate(test_loader)srn_test_scores.append(score)srn_dev_scores.append(max(runner.dev_scores))for length, dev_score, test_score in zip(lengths, srn_dev_scores, srn_test_scores):print(f[SRN] length:{length}, dev_score: {dev_score}, test_score: {test_score: .5f})# 将SRN在不同长度的验证集和测试集数据上的表现绘制成图片进行观察
import matplotlib.pyplot as pltplt.plot(lengths, srn_dev_scores, -o, color#e4007f, labelDev Accuracy)
plt.plot(lengths, srn_test_scores, -o, color#f19ec2, labelTest Accuracy)# 绘制坐标轴和图例
plt.ylabel(accuracy, fontsizelarge)
plt.xlabel(sequence length, fontsizelarge)
plt.legend(locupper right, fontsizex-large)fig_name ./images/6.7.pdf
plt.savefig(fig_name)
plt.show()nndl_3:
import torch
from matplotlib import pyplot as plt
from torch import nnclass Op(object):def __init__(self):passdef __call__(self, inputs):return self.forward(inputs)def forward(self, inputs):raise NotImplementedErrordef backward(self, inputs):raise NotImplementedError# 实现一个两层前馈神经网络
class Model_MLP_L2_V3(torch.nn.Module):def __init__(self, input_size, hidden_size, output_size):super(Model_MLP_L2_V3, self).__init__()self.fc1 torch.nn.Linear(input_size, hidden_size)w_ torch.normal(0, 0.01, size(hidden_size, input_size), requires_gradTrue)self.fc1.weight torch.nn.Parameter(w_)self.fc1.bias torch.nn.init.constant_(self.fc1.bias, val1.0)self.fc2 torch.nn.Linear(hidden_size, output_size)w2 torch.normal(0, 0.01, size(output_size, hidden_size), requires_gradTrue)self.fc2.weight nn.Parameter(w2)self.fc2.bias torch.nn.init.constant_(self.fc2.bias, val1.0)self.act torch.sigmoiddef forward(self, inputs):outputs self.fc1(inputs)outputs self.act(outputs)outputs self.fc2(outputs)return outputsclass RunnerV3(object):def __init__(self, model, optimizer, loss_fn, metric, **kwargs):self.model modelself.optimizer optimizerself.loss_fn loss_fnself.metric metric # 只用于计算评价指标# 记录训练过程中的评价指标变化情况self.dev_scores []# 记录训练过程中的损失函数变化情况self.train_epoch_losses [] # 一个epoch记录一次lossself.train_step_losses [] # 一个step记录一次lossself.dev_losses []# 记录全局最优指标self.best_score 0def train(self, train_loader, dev_loaderNone, **kwargs):# 将模型切换为训练模式self.model.train()# 传入训练轮数如果没有传入值则默认为0num_epochs kwargs.get(num_epochs, 0)# 传入log打印频率如果没有传入值则默认为100log_steps kwargs.get(log_steps, 100)# 评价频率eval_steps kwargs.get(eval_steps, 0)# 传入模型保存路径如果没有传入值则默认为best_model.pdparamssave_path kwargs.get(save_path, best_model.pdparams)custom_print_log kwargs.get(custom_print_log, None)# 训练总的步数num_training_steps num_epochs * len(train_loader)if eval_steps:if self.metric is None:raise RuntimeError(Error: Metric can not be None!)if dev_loader is None:raise RuntimeError(Error: dev_loader can not be None!)# 运行的step数目global_step 0# 进行num_epochs轮训练for epoch in range(num_epochs):# 用于统计训练集的损失total_loss 0for step, data in enumerate(train_loader):X, y data# 获取模型预测logits self.model(X)loss self.loss_fn(logits, y.long()) # 默认求meantotal_loss loss# 训练过程中每个step的loss进行保存self.train_step_losses.append((global_step, loss.item()))if log_steps and global_step % log_steps 0:print(f[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f})# 梯度反向传播计算每个参数的梯度值loss.backward()if custom_print_log:custom_print_log(self)# 小批量梯度下降进行参数更新self.optimizer.step()# 梯度归零self.optimizer.zero_grad()# 判断是否需要评价if eval_steps 0 and global_step 0 and \(global_step % eval_steps 0 or global_step (num_training_steps - 1)):dev_score, dev_loss self.evaluate(dev_loader, global_stepglobal_step)print(f[Evaluate] dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f})# 将模型切换为训练模式self.model.train()# 如果当前指标为最优指标保存该模型if dev_score self.best_score:self.save_model(save_path)print(f[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} -- {dev_score:.5f})self.best_score dev_scoreglobal_step 1# 当前epoch 训练loss累计值trn_loss (total_loss / len(train_loader)).item()# epoch粒度的训练loss保存self.train_epoch_losses.append(trn_loss)print([Train] Training done!)# 模型评估阶段使用torch.no_grad()控制不计算和存储梯度torch.no_grad()def evaluate(self, dev_loader, **kwargs):assert self.metric is not None# 将模型设置为评估模式self.model.eval()global_step kwargs.get(global_step, -1)# 用于统计训练集的损失total_loss 0# 重置评价self.metric.reset()# 遍历验证集每个批次for batch_id, data in enumerate(dev_loader):X, y data# 计算模型输出logits self.model(X)# 计算损失函数loss self.loss_fn(logits, y).item()# 累积损失total_loss loss# 累积评价self.metric.update(logits, y)dev_loss (total_loss / len(dev_loader))dev_score self.metric.accumulate()# 记录验证集lossif global_step ! -1:self.dev_losses.append((global_step, dev_loss))self.dev_scores.append(dev_score)return dev_score, dev_loss# 模型评估阶段使用torch.no_grad()控制不计算和存储梯度torch.no_grad()def predict(self, x, **kwargs):# 将模型设置为评估模式self.model.eval()# 运行模型前向计算得到预测值logits self.model(x)return logitsdef save_model(self, save_path):torch.save(self.model.state_dict(), save_path)def load_model(self, model_path):model_state_dict torch.load(model_path)self.model.load_state_dict(model_state_dict)class Accuracy():def __init__(self, is_logistTrue):# 用于统计正确的样本个数self.num_correct 0# 用于统计样本的总数self.num_count 0self.is_logist is_logistdef update(self, outputs, labels):if outputs.shape[1] 1: # 二分类outputs torch.squeeze(outputs, dim-1)if self.is_logist:# logist判断是否大于0preds torch.tensor((outputs 0), dtypetorch.float32)else:# 如果不是logist判断每个概率值是否大于0.5当大于0.5时类别为1否则类别为0preds torch.tensor((outputs 0.5), dtypetorch.float32)else:# 多分类时使用torch.argmax计算最大元素索引作为类别preds torch.argmax(outputs, dim1)# 获取本批数据中预测正确的样本个数labels torch.squeeze(labels, dim-1)batch_correct torch.sum(torch.tensor(preds labels, dtypetorch.float32)).cpu().numpy()batch_count len(labels)# 更新num_correct 和 num_countself.num_correct batch_correctself.num_count batch_countdef accumulate(self):# 使用累计的数据计算总的指标if self.num_count 0:return 0return self.num_correct / self.num_countdef reset(self):# 重置正确的数目和总数self.num_correct 0self.num_count 0def name(self):return Accuracy# 可视化
def plot(runner, fig_name):plt.figure(figsize(10, 5))plt.subplot(1, 2, 1)train_items runner.train_step_losses[::30]train_steps [x[0] for x in train_items]train_losses [x[1] for x in train_items]plt.plot(train_steps, train_losses, color#8E004D, labelTrain loss)if runner.dev_losses[0][0] ! -1:dev_steps [x[0] for x in runner.dev_losses]dev_losses [x[1] for x in runner.dev_losses]plt.plot(dev_steps, dev_losses, color#E20079, linestyle--, labelDev loss)# 绘制坐标轴和图例plt.ylabel(loss, fontsizex-large)plt.xlabel(step, fontsizex-large)plt.legend(locupper right, fontsizex-large)plt.subplot(1, 2, 2)# 绘制评价准确率变化曲线if runner.dev_losses[0][0] ! -1:plt.plot(dev_steps, runner.dev_scores,color#E20079, linestyle--, labelDev accuracy)else:plt.plot(list(range(len(runner.dev_scores))), runner.dev_scores,color#E20079, linestyle--, labelDev accuracy)# 绘制坐标轴和图例plt.ylabel(score, fontsizex-large)plt.xlabel(step, fontsizex-large)plt.legend(loclower right, fontsizex-large)plt.savefig(fig_name)plt.show()补充梯度截断
写到下一个实验才发现这里忘记写了
1.梯度打印函数
代码如下
import torch
from torch import nn# 梯度打印函数
W_list []
U_list []
b_list []
# 计算梯度范数
def custom_print_log(runner):model runner.modelW_grad_l2, U_grad_l2, b_grad_l2 0, 0, 0for name, param in model.named_parameters():if name rnn_model.W:W_grad_l2 torch.norm(param.grad, p2).numpy()if name rnn_model.U:U_grad_l2 torch.norm(param.grad, p2).numpy()if name rnn_model.b:b_grad_l2 torch.norm(param.grad, p2).numpy()print(f[Training] W_grad_l2: {W_grad_l2:.5f}, U_grad_l2: {U_grad_l2:.5f}, b_grad_l2: {b_grad_l2:.5f} )W_list.append(W_grad_l2)U_list.append(U_grad_l2)b_list.append(b_grad_l2)2.复现梯度爆炸现象
为了更好地复现梯度爆炸问题使用SGD优化器将批大小和学习率调大学习率为0.2同时在计算交叉熵损失时将reduction设置为sum表示将损失进行累加。
代码如下
# 复现梯度爆炸现象
import os
import random
import torch
import numpy as np
from nndl_3 import Accuracy, RunnerV3
from RNNandLSTM import DigitSumDataset, Model_RNN4SeqClass, SRN, load_data
from torch.utils.data import Dataset, DataLoadernp.random.seed(0)
random.seed(0)
torch.seed()# 训练轮次
num_epochs 50
# 学习率
lr 0.2
# 输入数字的类别数
num_digits 10
# 将数字映射为向量的维度
input_size 32
# 隐状态向量的维度
hidden_size 32
# 预测数字的类别数
num_classes 19
# 批大小
batch_size 64
# 模型保存目录
save_dir ./checkpoints# 可以设置不同的length进行不同长度数据的预测实验
length 20
print(f\n Training SRN with data of length {length}.)# 加载长度为length的数据
data_path f./datasets/{length}
train_examples, dev_examples, test_examples load_data(data_path)
train_set, dev_set, test_set DigitSumDataset(train_examples), DigitSumDataset(dev_examples),DigitSumDataset(test_examples)
train_loader DataLoader(train_set, batch_sizebatch_size)
dev_loader DataLoader(dev_set, batch_sizebatch_size)
test_loader DataLoader(test_set, batch_sizebatch_size)
# 实例化模型
base_model SRN(input_size, hidden_size)
model Model_RNN4SeqClass(base_model, num_digits, input_size, hidden_size, num_classes)
# 指定优化器
optimizer torch.optim.SGD(lrlr, paramsmodel.parameters())
# 定义评价指标
metric Accuracy()
# 定义损失函数
loss_fn nn.CrossEntropyLoss(reductionsum)# 基于以上组件实例化Runner
runner RunnerV3(model, optimizer, loss_fn, metric)# 进行模型训练
model_save_path os.path.join(save_dir, fsrn_explosion_model_{length}.pdparams)
runner.train(train_loader, dev_loader, num_epochsnum_epochs, eval_steps100, log_steps1,save_pathmodel_save_path, custom_print_logcustom_print_log)3.把l2范数变化图绘制出来
代码如下
# 绘制图片
import matplotlib.pyplot as plt
def plot_grad(W_list, U_list, b_list, save_path, keep_steps40):# 开始绘制图片plt.figure()# 默认保留前40步的结果steps list(range(keep_steps))plt.plot(steps, W_list[:keep_steps], r-, color#e4007f, labelW_grad_l2)plt.plot(steps, U_list[:keep_steps], -., color#f19ec2, labelU_grad_l2)plt.plot(steps, b_list[:keep_steps], --, color#000000, labelb_grad_l2)plt.xlabel(step)plt.ylabel(L2 Norm)plt.legend(locupper right)plt.show()plt.savefig(save_path)print(image has been saved to: , save_path)save_path f./images/6.8.pdf
plot_grad(W_list, U_list, b_list, save_path)# 加载训练过程中效果最好的模型
model_path os.path.join(save_dir, srn_explosion_model_20.pdparams)
runner.load_model(model_path)# 使用测试集评价模型获取测试集上的预测准确率
score, _ runner.evaluate(test_loader)
print(f[SRN] length:{length}, Score: {score: .5f})运行结果如下 4.使用梯度截断解决
只需要在RunnerV3的优化器参数更新之前加一行即可 nn.utils.clip_grad_norm_(parametersmodel.parameters(), max_norm20, norm_type2)其余代码不变
运行结果 这次的分享就到这里了下次再见~
