1. 通过图来理解什么是dropout

dropout 从字面意思就是‘丢掉’
丢掉？丢掉什么？
别急，我们来看看？

上图特征清晰明了，相必大家一眼就能认出是谁了把
根据这些特征，神经网络也能认出来，so easy

ok， 那我们增加难度，丢掉一些特征，如下图

你是不是立马就认出来了？

同样的对模型也这么做，我们把提取衣服特征的神经元去掉，模型鲁棒性就更强，为什么？因为模型学到认人，看脸就行，衣服什么的，无所谓

但这样模型非得看到左右脸才行，神经元提取的特征耦合度太高，我必须左右脸同时出现，模型才能作出判断，神经网络的鲁棒性仍然不够，怎么办？

我再随机抽取一半的神经元，让他们不参与任何计算，也不参与到权重的更新，比如这样

（打红叉表示不参与计算，不是被删掉的意思）
或者这样

当然，还有这种：

一般人光看xiong是认不出这是大幂幂的
这种情况就是dropout rate 设置太大，我们这是0.5，在训练的时候不幸丢掉了重点特征，造成模型overfitting了
当然有些同学说，老师老师，更据我多年阅人无数的经验，我认得出来

所以控制好dropout rate也是调参的关键，调好了就是加大模型鲁棒性，调不好就是overfitting

一般情况，dropout rate 设为0.3-0.5即可
所以你看，每次训练都随机让一定神经元停止参与运算，简单的操作让我们由一个模型演变成四个模型：

一个模型的作用效果，也转变成4个模型的效果和，更像一个多模型投票
所以，虽然第四个模型overfitting了，但是前三个也模型参与投票判断，第四个模型overfitting就被弱化了
所以，dropout的出现，使得模型稳定性和鲁棒性被大大提高了

例外一个有趣的例子来理解dropout
比如你们一个team有5个人，没个人负责一个模块，结果一个人生病请假了，但是他负责那个模块有问题，结果其它四个人没有办法只能加班加点给他改bug，最后他们都了解他那个模块。如果每个都请假一天，那么是不是他们team5个都成全能高手了？

2. 原理简述

dropout简单来讲，就是在迭代的过程中，随机的丢弃掉某些神经元，使得其训练只包含部分神经元的网络，因为任何神经元都有可能消失，所以模型会变得对神经元不那么敏感，表现就是对参数W的压缩，起到与L2正则化类似的作用。

执行步骤：

1->随机生成一个数值在（0-1）之间的，与A[l]维数相同的矩阵,drop_prob是保留概率

D[l] = np.random.rand(A[l].shape[0],A[l].shape[1])<drop_prob

2->丢弃部分神经元（前向传播）

A[l] = A[l]*D[l]
A[l] = A[l]/drop_prob  #保持期望值一样

3->丢弃部分神经元（后向传播）

dA[l] = dA[l]*D[l]
dA[l] = dA[l]/drop_prob  #保持期望值一样

3. 实验结果

不使用正则化，即drop_prob=1.0

训练正确率：1.0
测试错误率：0.925

使用Dropout正则化，drop_prob=0.6

训练正确率：0.919431279620853
测试错误率：0.95

以上可以看出，Dropout正则化可以有效的抑制神经网络过拟合

---

其它角度的理解

Dropout很好理解，通过在神经网络迭代过程中随机关闭一些神经元达到防止过拟合的目的。

为什么Dropout能够防止过拟合，如果我们在迭代过程中随机关闭一些神经元，那么模型将不会对某一个或一些神经元特别‘敏感’，因为无论哪个神经元随机都有被关闭的风险。

这也就间接的导致权重的取值范围尽量一致。

首先理解一下，神经元如何被“关闭”？

实践中，我们通过把神经元的输出置0来“关闭”神经元。

具体来说，执行下面4步：

建立一个维度与本层神经元数目相同的矩阵$D^{[l]}$.
根据概率（这里用变量keep_prob代表）将$D^{[l]}$中的元素设置为0或1。
将本层激活函数的输出与$D^{[l]}$.相乘作为新的输出。
新的输出除以keep_prob，这一步是为了保证得到的代价与未进行Dropout前一致，想像一下，你有5个1，求和等于5，现在随机删除了1/5的数字，为了保证结果还是5，需要对剩下来的每一个数字都除以1/5。

下面是前向传播的代码：

def forward_propagation_with_dropout(X, parameters, keep_prob = 0.5):
    """
    Implements the forward propagation: LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.



    Arguments:

    X -- input dataset, of shape (2, number of examples)

    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":

                    W1 -- weight matrix of shape (20, 2)
                    b1 -- bias vector of shape (20, 1)
                    W2 -- weight matrix of shape (3, 20)
                    b2 -- bias vector of shape (3, 1)
                    W3 -- weight matrix of shape (1, 3)
                    b3 -- bias vector of shape (1, 1)
    keep_prob - probability of keeping a neuron active during drop-out, scalar
    Returns:

    A3 -- last activation value, output of the forward propagation, of shape (1,1)

    cache -- tuple, information stored for computing the backward propagation

    """

    np.random.seed(1)

    # retrieve parameters

    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]
    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID

    Z1 = np.dot(W1, X) + b1

    A1 = relu(Z1)
    # 4 steps
    D1 = np.random.rand(Z1.shape[0], Z1.shape[1])     # Step 1: initialize matrix D1 = np.random.rand(..., ...)
    D1 = D1 < keep_prob                               # Step 2: convert entries of D1 to 0 or 1 (using keep_prob as the threshold)
    A1 = A1*D1                                        # Step 3: shut down some neurons of A1

    A1 = A1/keep_prob                                 # Step 4: scale the value of neurons that haven't been shut down
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)

    D2 = np.random.rand(Z2.shape[0], Z2.shape[1])                                       # Step 1: initialize matrix D2 = np.random.rand(..., ...)

    D2 = D2 < keep_prob                                # Step 2: convert entries of D2 to 0 or 1 (using keep_prob as the threshold)

    A2 = A2*D2                                         # Step 3: shut down some neurons of A2

    A2 = A2/keep_prob                                  # Step 4: scale the value of neurons that haven't been shut down

    Z3 = np.dot(W3, A2) + b3
    A3 = sigmoid(Z3)
    cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)
    return A3, cache

这里的一个小技巧是用D2 = D2 < keep_prob来生成0或1，因为python中的False和True等于0和1.
下面要写的代码是反向传播，注意，反向传播也要关闭对应的神经元，同样也需要除以keep_prob。

def backward_propagation_with_dropout(X, Y, cache, keep_prob):

    """
    Implements the backward propagation of our baseline model to which we added dropout.
    Arguments:
    X -- input dataset, of shape (2, number of examples)
    Y -- "true" labels vector, of shape (output size, number of examples)
    cache -- cache output from forward_propagation_with_dropout()
    keep_prob - probability of keeping a neuron active during drop-out, scalar

    Returns:

    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables

    """
    m = X.shape[1]

    (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache
    dZ3 = A3 - Y
    dW3 = 1./m * np.dot(dZ3, A2.T)
    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)
    dA2 = np.dot(W3.T, dZ3)

    dA2 = D2*dA2                     # Step 1: Apply mask D2 to shut down the same neurons as during the forward propagation

    dA2 = dA2/keep_prob              # Step 2: Scale the value of neurons that haven't been shut down
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = 1./m * np.dot(dZ2, A1.T)
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)

    dA1 = np.dot(W2.T, dZ2)
    dA1 = D1*dA1                     # Step 1: Apply mask D1 to shut down the same neurons as during the forward propagation

    dA1 = dA1/keep_prob              # Step 2: Scale the value of neurons that haven't been shut down
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    dW1 = 1./m * np.dot(dZ1, X.T)
    db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)
    gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,"dA2": dA2,
                 "dZ2": dZ2, "dW2": dW2, "db2": db2, "dA1": dA1, 
                 "dZ1": dZ1, "dW1": dW1, "db1": db1}

    return gradients

参考资料
[1] https://zhuanlan.zhihu.com/p/77609689
[2] https://zhuanlan.zhihu.com/p/29592806