循环神经网络
目标
能够说出循环神经网络的概念和作用能够说出循环神经网络的类型和应用场景能够说出LSTM的作用和原理能够说出GRU的作用和原理1. 循环神经网络的介绍
为什么有了神经网络还需要有循环神经网络？
在普通的神经网络中，信息的传递是单向的，这种限制虽然使得网络变得更容易学习，但在一定程度上也减弱了神经网络模型的能力。特别是在很多现实任务中，网络的输出不仅和当前时刻的输入相关，也和其过去一段时间的输出相关。此外，普通网络难以处理时序数据，比如视频、语音、文本等，时序数据的长度一般是不固定的，而前馈神经网络要求输入和输出的维数都是固定的，不能任意改变。因此，当处理这一类和时序相关的问题时，就需要一种能力更强的模型。
循环神经网络（Recurrent Neural Network，RNN）是一类具有短期记忆能力的神经网络。在循环神经网络中，神经元不但可以接受其它神经元的信息，也可以接受自身的信息，形成具有环路的网络结构。换句话说：神经元的输出可以在下一个时间步直接作用到自身（入）
通过简化图，我们看到RNN比传统的神经网络多了一个循环圈，这个循环表示的就是在下一个时间步（Time Step）上会返回作为输入的一部分，我们把RNN在时间点上展开，得到的图形如下：
或者是：
在不同的时间步，RNN的输入都将与之前的时间状态有关， t n t_n tn时刻网络的输出结果是该时刻的输入和所有历史共同作用的结果，这就达到了对时间序列建模的目的。
RNN的不同表示和功能可以通过下图看出：
图1：固定长度的输入和输出 (e.g. 图像分类)图2：序列输出 (e.g.图像转文字)图3：数列输入 (e.g. 文本分类)图4：异步的序列输入和输出(e.g.文本翻译).图5：同步的序列输入和输出 (e.g. 根据视频的每一帧来对视频进行分类)
2. LSTM和GRU
2.1 LSTM的基础介绍
假如现在有这样一个需求，根据现有文本预测下一个词语，比如天上的云朵漂浮在__，通过间隔不远的位置就可以预测出来词语是天上，但是对于其他一些句子，可能需要被预测的词语在前100个词语之前，那么此时由于间隔非常大，随着间隔的增加可能会导致真实的预测值对结果的影响变的非常小，而无法非常好的进行预测（RNN中的长期依赖问题（long-Term Dependencies））
那么为了解决这个问题需要LSTM（Long Short-Term Memory网络）
LSTM是一种RNN特殊的类型，可以学习长期依赖信息。在很多问题上，LSTM都取得相当巨大的成功，并得到了广泛的应用。
一个LSMT的单元就是下图中的一个绿色方框中的内容：
其中 σ \sigma σ表示sigmod函数，其他符号的含义：
2.2 LSTM的核心
LSTM的核心在于单元（细胞）中的状态，也就是上图中最上面的那根线。
但是如果只有上面那一条线，那么没有办法实现信息的增加或者删除，所以在LSTM是通过一个叫做门的结构实现，门可以选择让信息通过或者不通过。
这个门主要是通过sigmoid和点乘（pointwise multiplication）实现的
我们都知道， s i g m o i d sigmoid sigmoid的取值范围是在(0,1)之间，如果接近0表示不让任何信息通过，如果接近1表示所有的信息都会通过
2.3 逐步理解LSTM
2.3.1 遗忘门
遗忘门通过sigmoid函数来决定哪些信息会被遗忘
在下图就是 h t − 1 和 x t h_{t-1}和x_t ht−1和xt进行合并（concat）之后乘上权重和偏置，通过sigmoid函数，输出0-1之间的一个值，这个值会和前一次的细胞状态( C t − 1 C_{t-1} Ct−1)进行点乘，从而决定遗忘或者保留
2.3.2 输入门
下一步就是决定哪些新的信息会被保留，这个过程有两步：
一个被称为输入门的sigmoid 层决定哪些信息会被更新tanh会创造一个新的候选向量 C ~ t \widetilde{C}_{t} C t，后续可能会被添加到细胞状态中
例如：
我昨天吃了苹果，今天我想吃菠萝，在这个句子中，通过遗忘门可以遗忘苹果,同时更新新的主语为菠萝
现在就可以更新旧的细胞状态 C t − 1 C_{t-1} Ct−1为新的 C t C_{ t } Ct 了。
更新的构成很简单就是：
旧的细胞状态和遗忘门的结果相乘然后加上 输入门和tanh相乘的结果
2.3.3 输出门
最后，我们需要决定什么信息会被输出，也是一样这个输出经过变换之后会通过sigmoid函数的结果来决定那些细胞状态会被输出。
步骤如下：
前一次的输出和当前时间步的输入的组合结果通过sigmoid函数进行处理得到 O t O_t Ot更新后的细胞状态 C t C_t Ct会经过tanh层的处理，把数据转化到(-1,1)的区间tanh处理后的结果和 O t O_t Ot进行相乘，把结果输出同时传到下一个LSTM的单元
2.4 GRU，LSTM的变形
GRU(Gated Recurrent Unit),是一种LSTM的变形版本， 它将遗忘和输入门组合成一个“更新门”。它还合并了单元状态和隐藏状态，并进行了一些其他更改，由于他的模型比标准LSTM模型简单，所以越来越受欢迎。
LSTM内容参考地址：https://colah.github.io/posts/-08-Understanding-LSTMs/
3. 双向LSTM
单向的 RNN，是根据前面的信息推出后面的，但有时候只看前面的词是不够的， 可能需要预测的词语和后面的内容也相关，那么此时需要一种机制，能够让模型不仅能够从前往后的具有记忆，还需要从后往前需要记忆。此时双向LSTM就可以帮助我们解决这个问题
由于是双向LSTM，所以每个方向的LSTM都会有一个输出，最终的输出会有2部分，所以往往需要concat的操作
循环神经网络实现文本情感分类
目标
知道LSTM和GRU的使用方法及输入输出的格式能够应用LSTM和GRU实现文本情感分类1. Pytorch中LSTM和GRU模块使用
1.1 LSTM介绍
LSTM和GRU都是由torch.nn提供
通过观察文档，可知LSMT的参数，
torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional)
input_size：输入数据的形状，即embedding_dimhidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元num_layer：即RNN的中LSTM单元的层数batch_first：默认值为False，输入的数据需要[seq_len,batch,feature],如果为True，则为[batch,seq_len,feature]dropout:dropout的比例，默认值为0。dropout是一种训练过程中让部分参数随机失活的一种方式，能够提高训练速度，同时能够解决过拟合的问题。这里是在LSTM的最后一层，对每个输出进行dropoutbidirectional：是否使用双向LSTM,默认是False
实例化LSTM对象之后,不仅需要传入数据，还需要前一次的h_0(前一次的隐藏状态)和c_0（前一次memory）
即：lstm(input,(h_0,c_0))
LSTM的默认输出为output, (h_n, c_n)
output：(seq_len, batch, num_directions * hidden_size)—>batch_first=Falseh_n:(num_layers * num_directions, batch, hidden_size)c_n:(num_layers * num_directions, batch, hidden_size)
1.2 LSTM使用示例
假设数据输入为 input ,形状是[10,20]，假设embedding的形状是[100,30]
则LSTM使用示例如下：
batch_size =10seq_len = 20embedding_dim = 30word_vocab = 100hidden_size = 18num_layer = 2#准备输入数据input = torch.randint(low=0,high=100,size=(batch_size,seq_len))#准备embeddingembedding = torch.nn.Embedding(word_vocab,embedding_dim)lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer)#进行mebed操作embed = embedding(input) #[10,20,30]#转化数据为batch_first=Falseembed = embed.permute(1,0,2) #[20,10,30]#初始化状态， 如果不初始化，torch默认初始值为全0h_0 = torch.rand(num_layer,batch_size,hidden_size)c_0 = torch.rand(num_layer,batch_size,hidden_size)output,(h_1,c_1) = lstm(embed,(h_0,c_0))#output [20,10,1*18]#h_1 [2,10,18]#c_1 [2,10,18]
输出如下
In [122]: output.size()Out[122]: torch.Size([20, 10, 18])In [123]: h_1.size()Out[123]: torch.Size([2, 10, 18])In [124]: c_1.size()Out[124]: torch.Size([2, 10, 18])
通过前面的学习，我们知道，最后一次的h_1应该和output的最后一个time step的输出是一样的
通过下面的代码，我们来验证一下：
In [179]: a = output[-1,:,:]In [180]: a.size()Out[180]: torch.Size([10, 18])In [183]: b.size()Out[183]: torch.Size([10, 18])In [184]: a == bOut[184]:tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)
1.3 GRU的使用示例
GRU模块torch.nn.GRU，和LSTM的参数相同，含义相同，具体可参考文档
但是输入只剩下gru(input,h_0)，输出为output, h_n
其形状为：
output:(seq_len, batch, num_directions * hidden_size)h_n:(num_layers * num_directions, batch, hidden_size)
大家可以使用上述代码，观察GRU的输出形式
1.4 双向LSTM
如果需要使用双向LSTM，则在实例化LSTM的过程中，需要把LSTM中的bidriectional设置为True，同时h_0和c_0使用num_layer*2
观察效果，输出为
batch_size =10 #句子的数量seq_len = 20 #每个句子的长度embedding_dim = 30 #每个词语使用多长的向量表示word_vocab = 100 #词典中词语的总数hidden_size = 18 #隐层中lstm的个数num_layer = 2 #多少个隐藏层input = torch.randint(low=0,high=100,size=(batch_size,seq_len))embedding = torch.nn.Embedding(word_vocab,embedding_dim)lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer,bidirectional=True)embed = embedding(input) #[10,20,30]#转化数据为batch_first=Falseembed = embed.permute(1,0,2) #[20,10,30]h_0 = torch.rand(num_layer*2,batch_size,hidden_size)c_0 = torch.rand(num_layer*2,batch_size,hidden_size)output,(h_1,c_1) = lstm(embed,(h_0,c_0))In [135]: output.size()Out[135]: torch.Size([20, 10, 36])In [136]: h_1.size()Out[136]: torch.Size([4, 10, 18])In [137]: c_1.size()Out[137]: torch.Size([4, 10, 18])
在单向LSTM中，最后一个time step的输出的前hidden_size个和最后一层隐藏状态h_1的输出相同，那么双向LSTM呢？
双向LSTM中：
output：按照正反计算的结果顺序在第2个维度进行拼接，正向第一个拼接反向的最后一个输出
hidden state:按照得到的结果在第0个维度进行拼接，正向第一个之后接着是反向第一个
前向的LSTM中，最后一个time step的输出的前hidden_size个和最后一层向前传播h_1的输出相同
示例：
#-1是前向LSTM的最后一个，前18是前hidden_size个In [188]: a = output[-1,:,:18] #前项LSTM中最后一个time step的outputIn [189]: b = h_1[-2,:,:] #倒数第二个为前向In [190]: a.size()Out[190]: torch.Size([10, 18])In [191]: b.size()Out[191]: torch.Size([10, 18])In [192]: a == bOut[192]:tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)
后向LSTM中，最后一个time step的输出的后hidden_size个和最后一层后向传播的h_1的输出相同
示例
#0 是反向LSTM的最后一个，后18是后hidden_size个In [196]: c = output[0,:,18:] #后向LSTM中的最后一个输出In [197]: d = h_1[-1,:,:] #后向LSTM中的最后一个隐藏层状态In [198]: c == dOut[198]:tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)
1.4 LSTM和GRU的使用注意点
第一次调用之前，需要初始化隐藏状态，如果不初始化，默认创建全为0的隐藏状态往往会使用LSTM or GRU 的输出的最后一维的结果，来代表LSTM、GRU对文本处理的结果，其形状为[batch, num_directions*hidden_size]。 并不是所有模型都会使用最后一维的结果如果实例化LSTM的过程中，batch_first=False,则output[-1] or output[-1,:,:]可以获取最后一维如果实例化LSTM的过程中，batch_first=True,则output[:,-1,:]可以获取最后一维 如果结果是(seq_len, batch_size, num_directions * hidden_size),需要把它转化为(batch_size,seq_len, num_directions * hidden_size)的形状，不能够不是view等变形的方法，需要使用output.permute(1,0,2)，即交换0和1轴，实现上述效果使用双向LSTM的时候，往往会分别使用每个方向最后一次的output，作为当前数据经过双向LSTM的结果 即：torch.cat([h_1[-2,:,:],h_1[-1,:,:]],dim=-1)最后的表示的size是[batch_size,hidden_size*2]上述内容在GRU中同理2. 使用LSTM完成文本情感分类
在前面，我们使用了word embedding去实现了toy级别的文本情感分类，那么现在我们在这个模型中添加上LSTM层，观察分类效果。
为了达到更好的效果，对之前的模型做如下修改
MAX_LEN = 200构建dataset的过程，把数据转化为2分类的问题，pos为1，neg为0，否则25000个样本完成10个类别的划分数据量是不够的在实例化LSTM的时候，使用dropout=0.5，在model.eval()的过程中，dropout自动会为0
2.1 修改模型
class IMDBLstmmodel(nn.Module):def __init__(self):super(IMDBLstmmodel,self).__init__()self.hidden_size = 64self.embedding_dim = 200self.num_layer = 2self.bidriectional = Trueself.bi_num = 2 if self.bidriectional else 1self.dropout = 0.5#以上部分为超参数，可以自行修改self.embedding = nn.Embedding(len(ws),self.embedding_dim,padding_idx=ws.PAD) #[N,300]self.lstm = nn.LSTM(self.embedding_dim,self.hidden_size,self.num_layer,bidirectional=True,dropout=self.dropout)#使用两个全连接层，中间使用relu激活函数self.fc = nn.Linear(self.hidden_size*self.bi_num,20)self.fc2 = nn.Linear(20,2)def forward(self, x):x = self.embedding(x)x = x.permute(1,0,2) #进行轴交换h_0,c_0 = self.init_hidden_state(x.size(1))_,(h_n,c_n) = self.lstm(x,(h_0,c_0))#只要最后一个lstm单元处理的结果，这里多去的hidden stateout = torch.cat([h_n[-2, :, :], h_n[-1, :, :]], dim=-1)out = self.fc(out)out = F.relu(out)out = self.fc2(out)return F.log_softmax(out,dim=-1)def init_hidden_state(self,batch_size):h_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)c_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)return h_0,c_0
2.2 完成训练和测试代码
为了提高程序的运行速度，可以考虑把模型放在gup上运行，那么此时需要处理一下几点：
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")model.to(device)除了上述修改外，涉及计算的所有tensor都需要转化为CUDA的tensor 初始化的h_0,c_0训练集和测试集的input,traget在最后可以通过tensor.cpu()转化为torch的普通tensor
train_batch_size = 64test_batch_size = 5000# imdb_model = IMDBModel(MAX_LEN) #基础modelimdb_model = IMDBLstmmodel().to(device) #在gpu上运行，提高运行速度# imdb_model.load_state_dict(torch.load("model/mnist_net.pkl"))optimizer = optim.Adam(imdb_model.parameters())criterion = nn.CrossEntropyLoss()def train(epoch):mode = Trueimdb_model.train(mode)train_dataloader =get_dataloader(mode,train_batch_size)for idx,(target,input,input_lenght) in enumerate(train_dataloader):target = target.to(device)input = input.to(device)optimizer.zero_grad()output = imdb_model(input)loss = F.nll_loss(output,target) #traget需要是[0,9]，不能是[1-10]loss.backward()optimizer.step()if idx %10 == 0:pred = torch.max(output, dim=-1, keepdim=False)[-1]acc = pred.eq(target.data).cpu().numpy().mean()*100.print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\t ACC: {:.6f}'.format(epoch, idx * len(input), len(train_dataloader.dataset),100. * idx / len(train_dataloader), loss.item(),acc))torch.save(imdb_model.state_dict(), "model/mnist_net.pkl")torch.save(optimizer.state_dict(), 'model/mnist_optimizer.pkl')def test():mode = Falseimdb_model.eval()test_dataloader = get_dataloader(mode, test_batch_size)with torch.no_grad():for idx,(target, input, input_lenght) in enumerate(test_dataloader):target = target.to(device)input = input.to(device)output = imdb_model(input)test_loss = F.nll_loss(output, target,reduction="mean")pred = torch.max(output,dim=-1,keepdim=False)[-1]correct = pred.eq(target.data).sum()acc = 100. * pred.eq(target.data).cpu().numpy().mean()print('idx: {} Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(idx,test_loss, correct, target.size(0),acc))if __name__ == "__main__":test()for i in range(10):train(i)test()
2.3 模型训练的最终输出
...Train Epoch: 9 [20480/25000 (82%)]Loss: 0.017165 ACC: 100.000000Train Epoch: 9 [21120/25000 (84%)]Loss: 0.021572 ACC: 98.437500Train Epoch: 9 [21760/25000 (87%)]Loss: 0.058546 ACC: 98.437500Train Epoch: 9 [22400/25000 (90%)]Loss: 0.045248 ACC: 98.437500Train Epoch: 9 [23040/25000 (92%)]Loss: 0.027622 ACC: 98.437500Train Epoch: 9 [23680/25000 (95%)]Loss: 0.097722 ACC: 95.312500Train Epoch: 9 [24320/25000 (97%)]Loss: 0.026713 ACC: 98.437500Train Epoch: 9 [15600/25000 (100%)]Loss: 0.006082 ACC: 100.000000idx: 0 Test set: Avg. loss: 0.8794, Accuracy: 4053/5000 (81.06%)idx: 1 Test set: Avg. loss: 0.8791, Accuracy: 4018/5000 (80.36%)idx: 2 Test set: Avg. loss: 0.8250, Accuracy: 4087/5000 (81.74%)idx: 3 Test set: Avg. loss: 0.8380, Accuracy: 4074/5000 (81.48%)idx: 4 Test set: Avg. loss: 0.8696, Accuracy: 4027/5000 (80.54%)
可以看到模型的测试准确率稳定在81%左右。
大家可以把上述代码改为GRU，或者多层LSTM继续尝试，观察效果
Pytorch中的序列化容器
目标
知道梯度消失和梯度爆炸的原理和解决方法能够使用nn.Sequential完成模型的搭建知道nn.BatchNorm1d的使用方法知道nn.Dropout的使用方法1. 梯度消失和梯度爆炸
在使用pytorch中的序列化 容器之前，我们先来了解一下常见的梯度消失和梯度爆炸的问题
1.1 梯度消失
假设我们有四层极简神经网络：每层只有一个神经元
获取 w 1 的梯度有：▽ w 1 = x 1 ∗ f ( a 1 ) ’ ∗ w 2 ∗ f ( b 1 ) ’ ∗ w 3 ∗ ▽ o u t 获取w1的梯度有：▽w1 = x1*f(a1)’*w2*f(b1)’*w3*▽out 获取w1的梯度有：▽w1=x1∗f(a1)’∗w2∗f(b1)’∗w3∗▽out
假设我们使用sigmoid激活函数，即f为sigmoid函数，sigmoid的导数如下图
假设每层都取得sigmoid导函数的最大值1/4，那么在反向传播时， X 1 = 0.5 , w 1 = w 2 = w 3 = 0.5 X1=0.5,w1=w2=w3=0.5 X1=0.5,w1=w2=w3=0.5
∇ w 1 < 1 2 ∗ 1 4 ∗ 1 2 ∗ 1 4 ∗ 1 2 ∗ ∇ o u t = 1 2 7 ∇ o u t \nabla w1< \frac{1}{2} * \frac{1}{4}* \frac{1}{2}* \frac{1}{4}*\frac{1}{2}*\nabla out = \frac{1}{2^7} \nabla out ∇w1<21∗41∗21∗41∗21∗∇out=271∇out
当权重初始过小或使用易饱和神经元(sigmoid,tanh，) sigmoid在y=0,1处梯度接近0，而无法更新参数，时神经网络在反向传播时也会呈现指数倍缩小，产生“消失”现象。
1.2 梯度爆炸
假设 X 2 = 2 , w 1 = w 2 = w 3 = 2 X2=2,w1=w2=w3=2 X2=2,w1=w2=w3=2
$\nabla w1 = f’{a}2f‘{a}*x2\nabla out = 23f’(a)2 \nabla out $
当权重初始过大时，梯度神经网络在反向传播时也会呈现指数倍放大，产生“爆炸”现象。
1.3 解决梯度消失或者梯度爆炸的经验
替换易训练神经元**改进梯度优化算法：**使用adam等算法
使用batch normalization
2.nn.Sequential
nn.Sequential是一个有序的容器，其中传入的是构造器类(各种用来处理input的类)，最终input会被Sequential中的构造器类依次执行
例如：
layer = nn.Sequential(nn.Linear(input_dim, n_hidden_1), nn.ReLU(True)， #inplace=False 是否对输入进行就地修改，默认为Falsenn.Linear(n_hidden_1, n_hidden_2)，nn.ReLU(True)，nn.Linear(n_hidden_2, output_dim) # 最后一层不需要添加激活函数)
在上述就够中，可以直接调用layer(x)，得到输出
x的被执行顺序就是Sequential中定义的顺序：
被隐层1执行，形状变为[batch_size,n_hidden_1]被relu执行，形状不变被隐层2执行，形状变为[batch_size,n_hidden_2]被relu执行，形状不变被最后一层执行，形状变为[batch_size,output_dim]
3.nn.BatchNorm1d
batch normalization翻译成中文就是批规范化，即在每个batch训练的过程中，对参数进行归一化的处理，从而达到加快训练速度的效果。
以sigmoid激活函数为例，他在反向传播的过程中，在值为0,1的时候，梯度接近0，导致参数被更新的幅度很小，训练速度慢。但是如果对数据进行归一化之后，就会尽可能的把数据拉倒[0-1]的范围，从而让参数更新的幅度变大，提高训练的速度。
batchNorm一般会放到激活函数之后，即对输入进行激活处理之后再进入batchNorm
layer = nn.Sequential(nn.Linear(input_dim, n_hidden_1),nn.ReLU(True)， nn.BatchNorm1d(n_hidden_1)nn.Linear(n_hidden_1, n_hidden_2)，nn.ReLU(True)，nn.BatchNorm1d(n_hidden_2)nn.Linear(n_hidden_2, output_dim) )
4.nn.Dropout
dropout在前面已经介绍过，可以理解为对参数的随机失活
增加模型的稳健性可以解决过拟合的问题（增加模型的泛化能力）可以理解为训练后的模型是多个模型的组合之后的结果，类似随机森林。
layer = nn.Sequential(nn.Linear(input_dim, n_hidden_1),nn.ReLU(True)， nn.BatchNorm1d(n_hidden_1)nn.Dropout(0.3) #0.3 为dropout的比例，默认值为0.5nn.Linear(n_hidden_1, n_hidden_2)，nn.ReLU(True)，nn.BatchNorm1d(n_hidden_2)nn.Dropout(0.3)nn.Linear(n_hidden_2, output_dim) )
