吴恩达深度学习-Optimization+methods

@[TOC] 三种在更新参数的调优方法 gd，momentum，adam

1 - Gradient Descent

for $l = 1, ..., L$: $W^{[l]} = W^{[l]} - \alpha \text{ } dW^{[l]}$

$b^{[l]} = b^{[l]} - \alpha \text{ } db^{[l]}$

# GRADED FUNCTION: update_parameters_with_gd
def update_parameters_with_gd(parameters, grads, learning_rate):
    L = len(parameters) // 2 # number of layers in the neural networks

    # Update rule for each parameter
    for l in range(1, L):
        ### START CODE HERE ### (approx. 2 lines)
        parameters['W' + str(l)] = parameters['W' + str(l)] - learning_rate * grads['dW' + str(l)] 
        parameters['b' + str(l)] = parameters['b' + str(l)] - learning_rate * grads['db' + str(l)] 
        ### END CODE HERE ###
        
    return parameters

在随机梯度下降（Stochastic Gradient Descent, SGD）中，每次更新梯度时仅使用一个训练样本。当训练集较大时，SGD 的速度可能更快。但参数会以“振荡”的方式趋向最小值，而非平滑收敛。 实际应用中，通常采用介于单个样本与整个训练集之间的中间数量样本进行每次更新，即使用小批量梯度下降（Mini-batch Gradient Descent）。在这种方法中，您只需遍历小批量而非单个训练样本。

总结：

• 梯度下降、小批量梯度下降和随机梯度下降的区别在于每次更新所使用的样本数量；
• 需要调整学习率超参数 $\alpha$；
• 当选择合适的小批量大小时，通常其性能优于单纯的梯度下降或随机梯度下降，特别是在训练集较大的情况下。

(Batch) Gradient Descent:

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

Stochastic Gradient Descent:

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)

2 - Mini-Batch Gradient descent

1. Shuffle 乱序处理：X 和 Y 的每一列分别代表一个训练样本。请注意，X 和 Y 之间的随机乱序操作是同步进行的。如此一来，乱序之后，X 的第 $i$ 列样本将与 Y 中第 $i$ 个标签相对应。进行乱序步骤的目的是确保样本能够随机地分配到不同的 mini-batch 中。
2. Partition 分区处理：将已乱序的（X, Y）按照 mini_batch_size（此处为 64）大小划分为多个 mini-batch，最后一区块可能不足mini_batch_size

# GRADED FUNCTION: random_mini_batches
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))  # 生成指定范围内 [0, m-1] 的整数随机排列。
    shuffled_X = X[:, permutation]	# 按照list重新排列数据
    shuffled_Y = Y[:, permutation].reshape((1,m))

    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    num_complete_minibatches = 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[ : , num_complete_minibatches * mini_batch_size : m]
        mini_batch_Y = shuffled_Y[ : , num_complete_minibatches * mini_batch_size : m]
        ### END CODE HERE ###
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
    
    return mini_batches

• Shuffling 和 Partitioning 是构建 mini-batch 所需的两个关键步骤。
• mini-batch 的大小通常选取2的幂作为基数，例如 16、32、64、128 等。

3 - Momentum

由于 mini-batch 梯度下降在观察到一小部分样本后就进行参数更新，更新的方向存在一定的方差，因此 mini-batch 梯度下降收敛时的路径会呈现出“振荡”现象。引入动量法可以减少这些振荡。 动量法考虑了过去梯度的方向，以平滑更新过程。我们将存储之前梯度的“方向”在一个变量 $v$ 中。形式上，这将是前几步梯度的指数加权平均。你也可以将 $v$ 视为一个沿斜坡滚下的球的“速度”，根据梯度（或斜坡）的方向积累速度（动量）。

initialize_velocity

# GRADED FUNCTION: initialize_velocity

def initialize_velocity(parameters):
    """
    Initializes the velocity as a python dictionary with:
                - keys: "dW1", "db1", ..., "dWL", "dbL" 
                - values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters.
    Arguments:
    parameters -- python dictionary containing your parameters.
                    parameters['W' + str(l)] = Wl
                    parameters['b' + str(l)] = bl
    
    Returns:
    v -- python dictionary containing the current velocity.
                    v['dW' + str(l)] = velocity of dWl
                    v['db' + str(l)] = velocity of dbl
    """
    
    L = len(parameters) // 2 # number of layers in the neural networks
    v = {}
    
    # Initialize velocity
    for l in range(L):
        ### START CODE HERE ### (approx. 2 lines)
        v['dW' + str(l+1)] = np.zeros((parameters['W' + str(l+1)].shape[0] , parameters['W' + str(l+1)].shape[1]))
        v['db' + str(l+1)] = np.zeros((parameters['b' + str(l+1)].shape[0] , parameters['b' + str(l+1)].shape[1]))
        ### END CODE HERE ###
        
    return v

for $l = 1, ..., L$: