在深層神經網路那篇部落格中講了，深層神經網路的區域性最優解問題，深層神經網路中存在區域性極小點的可能性比較小，大部分是鞍點。因為鞍面上的梯度接近於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