深度学习—加快梯度下降收敛速度（一）：mini-batch、Stochastic gradient descent

在深层神经网络那篇博客中讲了，深层神经网络的局部最优解问题，深层神经网络中存在局部极小点的可能性比较小，大部分是鞍点。因为鞍面上的梯度接近于0，在鞍面上行走是非常缓慢的。因此，必须想办法加速收敛速度，使其更快找到全局最优解。本文将介绍mini-batch与Stochastic gradient descent方法。



1.mini-batch

之前的梯度下降法是将训练集所有的梯度计算之后，再更新参数，这样大部分时间浪费在计算梯度上。而mini-batch是将训练集分组，分组之后，分别对每组求梯度，然后更新参数。加入分 8组，则每次迭代将会做8次梯度下降，更新8次参数。所以mini-batch比传统的梯度下降法下降的速度快，但是mini-batch的cost曲线没有传统梯度下降法的cost曲线光滑，大致对比如下：

梯度下降过程



mini-batch下降过程



mini-batch实现步骤：

确定mini-batch size，一般有32、64、128等，按自己的数据集而定，确定mini-batch_num=m/mini-batch_num + 1；

在分组之前将原数据集顺序打乱，随机打乱；

分组，将打乱后的数据集分组；

将分好后的mini-batch组放进迭代循环中，每次循环都做mini-batch_num次梯度下降。

2.Stochastic gradient descent

Stochastic gradient descent可以看做是mini-batch的一种特殊情况，当mini-batch size等于1时，mini-batch就退化为Stochastic gradient descent。此时每次迭代中，对于数据集中每个样本都做一次梯度下降，其梯度下降过程大致如下所示：



从Stochastic gradient descent的梯度下降图可以看出，下降速度虽然比传统梯度下降速度快，但是曲线比较曲折，没有mini-batch的曲线直，因此，多数情况下会使用mini-batch。

3.三者优缺点对比

Stochastic gradient descent无法利用向量化，并行运算受限，mini-batch和batch gradient decent可以利用向量化，有并行运算优势；

Stochastic gradient descent很难收敛到最优点，mini-batch和batch gradient decent可以收敛到最优点；

Stochastic gradient descent和mini-batch收敛速度快，batch gradient decent收敛速度慢。

Stochastic gradient descent Python源码：

X = data_input
Y = labels
parameters = initialize_parameters(layers_dims)
for i in range(0, num_iterations):
for j in range(0, m):
# Forward propagation
a, caches = forward_propagation(X[:,j], parameters)
# Compute cost
cost = compute_cost(a, Y[:,j])
# Backward propagation
grads = backward_propagation(a, caches, parameters)
# Update parameters.
parameters = update_parameters(parameters, grads)

mini-batch python 源码：

def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
"""
Creates a list of random minibatches from (X, Y)

Arguments:
X -- input data, of shape (input size, number of examples)
Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
mini_batch_size -- size of the mini-batches, integer

Returns:
mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
"""

np.random.seed(seed)            # To make your "random" minibatches the same as ours
m = X.shape[1]                  # number of training examples
mini_batches = []

# Step 1: Shuffle (X, Y)
permutation = list(np.random.permutation(m))
shuffled_X = X[:, permutation]
shuffled_Y = Y[:, permutation].reshape((1,m))

# Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
num_complete_minibatches = int(math.floor(m/mini_batch_size)) # number of mini batches of size mini_batch_size in your partitionning
for k in range(0, num_complete_minibatches):
### START CODE HERE ### (approx. 2 lines)
mini_batch_X = shuffled_X[:, k * mini_batch_size:(k + 1) * mini_batch_size]
mini_batch_Y = shuffled_Y[:, k * mini_batch_size:(k + 1) * mini_batch_size]
### END CODE HERE ###
mini_batch = (mini_batch_X, mini_batch_Y)
mini_batches.append(mini_batch)

# Handling the end case (last mini-batch < mini_batch_size)
if m % mini_batch_size != 0:
### START CODE HERE ### (approx. 2 lines)
mini_batch_X = shuffled_X[:, (k + 1) * mini_batch_size:m]
mini_batch_Y = shuffled_Y[:, (k + 1) * mini_batch_size:m]
### END CODE HERE ###
mini_batch = (mini_batch_X, mini_batch_Y)
mini_batches.append(mini_batch)

return mini_batches