Dropout在RNN中的应用综述

Dropout

受性别在进化中的作用的启发，Hinton等人最先提出Dropout，即暂时从网络中移除神经网络中的单元。 Srivastava等人将Dropout应用于前馈神经网络和受限玻尔兹曼机，并注意到隐层0.5，输入层0.2的 dropout 率 适用于各种任务。

对于每个训练样本，重新调整网络并丢弃一组新的神经元。在测试时，权重需要乘以相关单元的dropout率。

Srivatava等进一步发现“随着数据集变大，dropout的增益增加到一个点然后下降。 这表明，对于任何给定的网络结构和dropout率，存在一个“最佳点”。

Srivastava等用伯努利分别来表示隐藏单元被激活的概率，其中值1为概率p，否则为0。

dropout的示例代码如下：

1
2
3
4
5
6
7
8
9
10
11

class Dropout():
    def __init__(self, prob=0.5):
        self.prob = prob
        self.params = []
    def forward(self,X):
        self.mask = np.random.binomial(1,self.prob,size=X.shape) / self.prob
        out = X * self.mask
    return out.reshape(X.shape)
    def backward(self,dout):
        dX = dout * self.mask
        return dX,[]

DropConnect

在Dropout之后，Wan等人的进一步提出了DropConnect，它“通过随机丢弃权重而不是激活来扩展Dropout”。 “使用Drop Connect, drop的是每个连接，而不是每个输出单元。”与Dropout一样，该技术仅适用于全连接层。

1
2
3
4
5
6
7
8
9
10

class RNN:
# ...
    def step(self, x):
        # update the hidden state
        self.h = np.tanh(np.dot(self.W_hh, self.h) + np.dot(self.W_xh, x))
        # compute the output vector
        y = np.dot(self.W_hy, self.h)
        return y
rnn = RNN()
y = rnn.step(x) # x is an input ve

Dropout用于RNN

作为克服应用于RNN的dropout性能问题的一种方法，Zaremba和Pham等仅将dropout应用于非循环连接（Dropout未应用于隐藏状态）。 “通过不对循环连接使用dropout，LSTM可以从dropout正则化中受益，而不会牺牲其宝贵的记忆能力。”

Gal和Ghahramani（2015）分析了将Dropout应用于仅前馈RNN的部分，发现这种方法仍然导致过拟合。 他们提出了“变分Dropout”，通过重复“输入，输出和循环层的每个时间步长相同的dropout掩码（在每个时间步骤丢弃相同的网络单元）”，使用贝叶斯解释，他们看到了语言的改进 建模和情感分析任务超过’纯dropout’。

与Moon和Gal和Ghahramani一样，Semeniuta等人提出将dropout应用于RNN的循环连接，以便可以对循环权重进行正则化以提高性能。 Gal和Ghahramani使用网络的隐藏状态作为计算门值和小区更新以及使用dropout的子网络的输入来正则化子网络（图9b）。 Semeniuta等人的不同之处在于他们认为“整个架构以隐藏状态为关键部分并使整个网络正则化”。 这类似于Moon等人的概念（如图9a所示），但Semeniuta等人发现根据Moon等人直接丢弃先前的状态产生了混合结果，而将dropout应用于隐藏状态更新向量是一种更有原则的方法。

“我们的技术允许在模型权重上添加强大的正则化器，负责学习短期和长期依赖性，而不会影响捕获长期关系的能力，这对于处理自然语言时的模型尤其重要。“

Zoneout

作为dropout的一个变种，Krueger等人提出了Zoneout，它“不是将某些单位的激活设置为0，Zoneout随机替换某些单位的激活与他们从前一个时间步的激活。”这“使网络更容易保留以前时间步的信息向前发展，促进而不是阻碍梯度信息向后流动“。

1
2
3
4
5
6
7

if self.is_training:
    new_state = (1 - state_part_zoneout_prob) * tf.python.nn_ops.dropout(
        new_state_part - state_part, (1 - state_part_zoneout_prob),
         seed=self._seed) + state_part
else:
    new_state = state_part_zoneout_prob * state_part 
        + (1 - state_part_zoneout_prob) * new_state_part

AWD-LSTM

在关于语言建模的RNN正规化的开创性工作中，Merity等人提出了一种他们称为AWD-LSTM的方法。在这种方法中，Merity等人使用对隐藏权重矩阵使用DropConnect，而所有其他dropout操作使用变分dropout，以及包括随机长度在内的其他几种正则化策略反向传播到时间（BPTT），激活正则化（AR）和时间激活正则化（TAR）。

关于DropConnect， Metity等人年提到“由于相同的权重在多个时间步长重复使用，同一个权重在整个前向和后向传播中保持下降。结果类似于变分dropout，它通过对ht-1执行dropout，将相同的dropout掩码应用于LSTM内的循环连接，除了将dropout应用于循环权重。“

关于变分dropout的使用，Metity等注意到“mini-batch中的每个示例都使用独特的dropout掩模，而不是在所有示例中使用单个dropout掩模，确保元素的多样性。”

利用Gal＆Ghahramani的嵌入式dropout，Metity等人还注意到，这“相当于在字级别对嵌入矩阵执行dropout，其中dropout是在所有字向量的嵌入中广播的。” “由于在用于完整前向和后向传递的嵌入矩阵上发生了dropout，这意味着特定字的所有出现都将在该传递中消失，相当于在one-hot嵌入和之间的连接上执行变分dropout。

Merity等人使用的代码：

1
2
3
4
5
6
7
8
9
10

class LockedDropout(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self, x, dropout=0.5):
        if not self.training or not dropout:
            return x
        m = x.data.new(1, x.size(1), x.size(2)).bernoulli_(1 - dropout)
        mask = Variable(m, requires_grad=False) / (1 - dropout)
        mask = mask.expand_as(x)
        return mask * x

因此在RNNModel（nn.Module）中应用前向方法dropout的位置（注意self.lockdrop = LockedDropout（mask = mask））：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def forward(self, input, hidden, return_h=False):
    emb = embedded_dropout(self.encoder, input, dropout=self.dropoute 
    if self.training else 0)
    emb = self.lockdrop(emb, self




    
.dropouti)
    raw_output = emb
    new_hidden = []
    raw_outputs = []
    outputs = []
    for l, rnn in enumerate(self.rnns):
        current_input = raw_output
        raw_output, new_h = rnn(raw_output, hidden[l])
        new_hidden.append(new_h)
        raw_outputs.append(raw_output)
        if l != self.nlayers - 1:
            raw_output = self.lockdrop(raw_output, self.dropouth)
            outputs.append(raw_output)
    hidden = new_hidden
    output = self.lockdrop(raw_output, self.dropout)
    outputs.append(output)
    result = output.view(output.size(0)*output.size(1), output.size(2))
    if return_h:
        return result, hidden, raw_outputs, outputs
    return result, hidden

DropConnect应用于上述相同RNNModel的init方法中：

1
2
3
4
5
6
7
8

if rnn_type == 'LSTM':
    self.rnns = [torch.nn.LSTM(ninp if l == 0 else nhid,
     nhid if l != nlayers - 1 
        else (ninp if tie_weights else nhid),
      1, dropout=0) for l in range(nlayers)]
    if wdrop:
        self.rnns = [WeightDrop(rnn, ['weight_hh_l0'], dropout=wdrop)
                for rnn in self.rnns]

WeightDrop类的关键部分是以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def _setweights(self):
    for name_w in self.weights:
        raw_w = getattr(self.module, name_w + '_raw')
        w = None
        if self.variational:
            mask = torch.autograd.Variable(torch.ones(raw_w.size(0), 1))
            if raw_w.is_cuda: mask = mask.cuda()
            mask = torch.nn.functional.dropout(mask, p=self.dropout,
             training=True)
            w = mask.expand_as(raw_w) * raw_w
        else:
            w = torch.nn.functional.dropout(raw_w, p=self.dropout,
         training=self.training)
        setattr(self.module, name_w, w)

原文链接： https://medium.com/@bingobee01/a-review-of-dropout-as-applied-to-rnns-72e79ecd5b7b

References:

J. Bayer, C. Osendorfer, D. Korhammer, N. Chen, S. Urban, P. van der Smagt. 2013. On Fast Dropout and its Applicability to Recurrent Networks.

Y. Bengio, P. Simard, P. Frasconi. 1994. Learning long-term dependencies with gradient descent is difficult.

cs231n. https://cs231n.github.io/convolutional-networks/

deepnotes.io . https://deepnotes.io/dropout

Y. Gal, abd Z. Ghahramani. 2015. A Theoretically Grounded Application of Dropout in Recurrent Neural Networks.

G. E. Hinton, N. Srivastava, A. Krizhevsky, I. Sutskever and R. R. Salakhutdinov. 2012. Improving neural networks by preventing co-adaptation of feature detectors.

karpathy.github.io . https://karpathy.github.io/2015/05/21/rnn-effectiveness/

D. Krueger, T. Maharaj, J. Kramár, M. Pezeshki, N. Ballas, N. Rosemary Ke, A. Goyal, Y. Bengio, A. Courville, C. Pal. 2016. Zoneout: Regularizing RNNs by Randomly Preserving Hidden Activations.

S. Merity, N. Shirish Keskar, R. Socher. 2017. Regularizing and Optimizing LSTM Language Models.

ml-cheatsheet.readthedocs.io . https://ml-cheatsheet.readthedocs.io/en/latest/nn_concepts.html

T. Moon, H. Choi, H. Lee, I. Song. 2015. Rnndrop: A novel dropout for rnns.

P. Morerio, J. Cavazza, R. Volpi, R.Vidal, V. Murino. 2017. Curriculum Dropout

A. Narwekar, A. Pampari. 2016. Recurrent Neural Network Architectures. http://slazebni.cs.illinois.edu/spring17/lec20_rnn.pdf

V. Pham, T. Bluche, C. Kermorvant, J. Louradour. 2013. Dropout improves Recurrent Neural Networks for Handwriting Recognition

S. Semeniuta, A. Severyn, E. Barth. 2016. Recurrent Dropout without Memory Loss.