深度学习作业L2W2：Optimization methods

最新推荐文章于 2024-06-09 15:45:25 发布
最新推荐文章于 2024-06-09 15:45:25 发布
阅读量231 收藏
点赞数
分类专栏： 深度学习笔记 文章标签： 深度学习 python 神经网络 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44334615/article/details/105607990
版权

本次实验主要介绍L2第二周的各项优化技术的实现。

batch梯度下降

简单的batch梯度下降更新公式为w = w - learning_rate*dw

# GRADED FUNCTION: update_parameters_with_gd

def update_parameters_with_gd(parameters, grads, learning_rate):
    """
    Update parameters using one step of gradient descent
    
    Arguments:
    parameters -- python dictionary containing your parameters to be updated:
                    parameters['W' + str(l)] = Wl
                    parameters['b' + str(l)] = bl
    grads -- python dictionary containing your gradients to update each parameters:
                    grads['dW' + str(l)] = dWl
                    grads['db' + str(l)] = dbl
    learning_rate -- the learning rate, scalar.
    
    Returns:
    parameters -- python dictionary containing your updated parameters 
    """

    L = len(parameters) // 2 # number of layers in the neural networks

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

Mini-Batch Gradient descent

我们首先将训练集X随机打乱以保证分出的每个batch分布大体一致。随后每次迭代只训练一个batch就进行参数更新。注意不要忘了最后剩下的不足一个batch的部分

# 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))
    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 = 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:]
        mini_batch_Y = shuffled_Y[:, (k+1)*mini_batch_size:]
        ### END CODE HERE ###
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
    
    return mini_batches

Momentum

初始化滑动平均值数组，其shape应当和w，b的shape相同

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)
        v["db" + str(l+1)] = np.zeros(parameters["b" + str(l+1)].shape)
        ### END CODE HERE ###
        
    return v

对于每轮迭代，计算出v值后再进行参数更新

# GRADED FUNCTION: update_parameters_with_momentum

def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate):
    """
    Update parameters using Momentum
    
    Arguments:
    parameters -- python dictionary containing your parameters:
                    parameters['W' + str(l)] = Wl
                    parameters['b' + str(l)] = bl
    grads -- python dictionary containing your gradients for each parameters:
                    grads['dW' + str(l)] = dWl
                    grads['db' + str(l)] = dbl
    v -- python dictionary containing the current velocity:
                    v['dW' + str(l)] = ...
                    v['db' + str(l)] = ...
    beta -- the momentum hyperparameter, scalar
    learning_rate -- the learning rate, scalar
    
    Returns:
    parameters -- python dictionary containing your updated parameters 
    v -- python dictionary containing your updated velocities
    """

    L = len(parameters) // 2 # number of layers in the neural networks
    
    # Momentum update for each parameter
    for l in range(L):
        
        ### START CODE HERE ### (approx. 4 lines)
        # compute velocities
        v["dW" + str(l+1)] = beta*v["dW" + str(l+1)] + (1-beta)*grads["dW" + str(l+1)]
        v["db" + str(l+1)] = beta*v["db" + str(l+1)] + (1-beta)*grads["db" + str(l+1)]
        # update parameters
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - v["dW" + str(l+1)]*learning_rate
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - v["db" + str(l+1)]*learning_rate
        ### END CODE HERE ###
        
    return parameters, v

Adam

在momentum的基础上还要计算参数平方的滑动平均值矩阵

# GRADED FUNCTION: initialize_adam

def initialize_adam(parameters) :
    """
    Initializes v and s as two python dictionaries 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 that will contain the exponentially weighted average of the gradient.
                    v["dW" + str(l)] = ...
                    v["db" + str(l)] = ...
    s -- python dictionary that will contain the exponentially weighted average of the squared gradient.
                    s["dW" + str(l)] = ...
                    s["db" + str(l)] = ...

    """
    
    L = len(parameters) // 2 # number of layers in the neural networks
    v = {}
    s = {}
    
    # Initialize v, s. Input: "parameters". Outputs: "v, s".
    for l in range(L):
    ### START CODE HERE ### (approx. 4 lines)
        v["dW" + str(l+1)] = np.zeros(parameters["W" + str(l+1)].shape)
        v["db" + str(l+1)] = np.zeros(parameters["b" + str(l+1)].shape)
        s["dW" + str(l+1)] = np.zeros(parameters["W" + str(l+1)].shape)
        s["db" + str(l+1)] = np.zeros(parameters["b" + str(l+1)].shape)
    ### END CODE HERE ###
    
    return v, s

每次迭代先计算出v值和s值，并且计算出偏差修正后的v和s，利用v s更新参数

# GRADED FUNCTION: update_parameters_with_adam

def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01,
                                beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):
    """
    Update parameters using Adam
    
    Arguments:
    parameters -- python dictionary containing your parameters:
                    parameters['W' + str(l)] = Wl
                    parameters['b' + str(l)] = bl
    grads -- python dictionary containing your gradients for each parameters:
                    grads['dW' + str(l)] = dWl
                    grads['db' + str(l)] = dbl
    v -- Adam variable, moving average of the first gradient, python dictionary
    s -- Adam variable, moving average of the squared gradient, python dictionary
    learning_rate -- the learning rate, scalar.
    beta1 -- Exponential decay hyperparameter for the first moment estimates 
    beta2 -- Exponential decay hyperparameter for the second moment estimates 
    epsilon -- hyperparameter preventing division by zero in Adam updates

    Returns:
    parameters -- python dictionary containing your updated parameters 
    v -- Adam variable, moving average of the first gradient, python dictionary
    s -- Adam variable, moving average of the squared gradient, python dictionary
    """
    
    L = len(parameters) // 2                 # number of layers in the neural networks
    v_corrected = {}                         # Initializing first moment estimate, python dictionary
    s_corrected = {}                         # Initializing second moment estimate, python dictionary
    
    # Perform Adam update on all parameters
    for l in range(L):
        # Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v".
        ### START CODE HERE ### (approx. 2 lines)
        v["dW" + str(l+1)] = beta1*v["dW" + str(l+1)] + (1-beta1)*grads["dW" + str(l+1)]
        v["db" + str(l+1)] = beta1*v["db" + str(l+1)] + (1-beta1)*grads["db" + str(l+1)]
        ### END CODE HERE ###

        # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected".
        ### START CODE HERE ### (approx. 2 lines)
        v_corrected["dW" + str(l+1)] = v["dW" + str(l+1)]/(1-np.power(beta1, t))
        v_corrected["db" + str(l+1)] =  v["db" + str(l+1)]/(1-np.power(beta1, t))
        ### END CODE HERE ###

        # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s".
        ### START CODE HERE ### (approx. 2 lines)
        s["dW" + str(l+1)] = beta2*s["dW" + str(l+1)] + (1-beta2)*grads["dW" + str(l+1)]*grads["dW" + str(l+1)]
        s["db" + str(l+1)] = beta2*s["db" + str(l+1)] + (1-beta2)*grads["db" + str(l+1)]*grads["db" + str(l+1)]
        ### END CODE HERE ###

        # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected".
        ### START CODE HERE ### (approx. 2 lines)
        s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)]/(1-np.power(beta2, t))
        s_corrected["db" + str(l+1)] = s["db" + str(l+1)]/(1-np.power(beta2, t))
        ### END CODE HERE ###

        # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters".
        ### START CODE HERE ### (approx. 2 lines)
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate* v_corrected["dW" + str(l+1)]/(np.sqrt(s_corrected["dW" + str(l+1)]+epsilon))
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate* v_corrected["db" + str(l+1)]/(np.sqrt(s_corrected["db" + str(l+1)]+epsilon))
        ### END CODE HERE ###

    return parameters, v, s

货比三家

相同训练轮数下
mini-batch 梯度下降：
在这里插入图片描述
mini-batch梯度下降+momentum
在这里插入图片描述
mini-batch梯度下降+Adam
在这里插入图片描述
可见Adam算法优化的确是最快的。

awake020
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
L1—L2 optimization in signal and image processing
05-13
信号处理和图像处理中的L1-L2 optimization
Python吴恩达深度学习作业9 -- 梯度下降的优化
qq_41476257的博客
06-06 1096
到目前为止，你一直使用梯度下降来更新参数并使损失降至最低。在本笔记本中，你将学习更多高级的优化方法，以加快学习速度，甚至可以使你的损失函数的获得更低的最终值。一个好的优化算法可以使需要训练几天的网络，训练仅仅几个小时就能获得良好的结果。梯度下降好比在损失函数JJJ上“下坡”。就像下图： 损失最小化好比在丘陵景观中寻找最低点在训练的每个步骤中，你都按照一定的方向更新参数，以尝试到达最低点。符号：与往常一样，∂J∂a=da\frac {\partial J}{\partial a}=da∂a∂J​=da适合用于
梯度下降法 Gradient descent
zshxsr的博客
03-11 501
经常听到梯度下降法，只知道它是用于优化求解问题。即 沿着梯度的反方向（坡度最陡的方向）进行权值更新。为什么局部梯度下降最快的方向就是梯度的负方向呢？ 梯度 梯度就是表示某一个函数在当前位置的导数。为自变量，为关于的函数；为梯度 如果函数为凸函数，那么就可以根据梯度下降算法进行优化，求得使最小的参数； 为当前下山的位置，为下山移动一小步之后的位置，为学习因子，即步长。 梯度更新公...
【Batch_size 与 梯度 之间的关系】
yongjie
06-19 1400
知乎链接：https://zhuanlan.zhihu.com/p/488198704。
深度学习3：手动实现L2正则化（L2 Regularization）
ChainingBlocks
12-15 1万+
在神经网络中，正则化的作用是防止过拟合，本文将结合一个实例来讲解神经网络中的L2正则化，并手动（不使用框架）实现出来。先来看代码运行结果： 增加L2正则化之前 增加L2正则化之后：L2正则化为：λ2 m ||W|| 2  \frac {\lambda}{2 \text{ }m}||W||^2， 其中λ \lambda是超参数， m是一个batch中数据个数， 除以2的原因是在求导的时候抵消掉
吴恩达深度学习l2week2编程作业—Optimization Methods（最新中文跑通版）
na__D的博客
01-06 1543
具有动量的梯度下降通常可以有很好的效果，但由于小的学习速率和简单的数据集所以它的影响几乎是轻微的。另一方面，Adam明显优于小批量梯度下降和具有动量的梯度下降，如果在这个简单的模型上运行更多时间的数据集，这三种方法都会产生非常好的结果，然而，我们已经看到Adam收敛得更快。Adam的一些优点包括相对较低的内存要求（虽然比梯度下降和动量下降更高）和通常运作良好，即使对参数进行微调（除了学习率α）
深度学习第三章：深度学习基础（2）【笔记】
最新发布
Bright20040513的博客
06-09 786
​ 以前在神经网络训练中，只是对输入层数据进行归一化处理，却没有在中间层进行归一化处理。要知道，虽然我们对输入数据进行了归一化处理，但是输入数据经过 $ \sigma(WX+b) $ 这样的矩阵乘法以及非线性运算之后，其数据分布很可能被改变，而随着深度网络的多层运算之后，数据分布的变化将越来越大。如果我们能在网络的中间也进行归一化处理，是否对网络的训练起到改进作用呢？答案是肯定的。​ 这种在神经网络中间层也进行归一化处理，使训练效果更好的方法，就是批归一化Batch Normalization（BN）。
神经网络与深度学习【自用】
qq_61803559的博客
03-10 2325
自用
人工智能英文版课件：Optimization methods.pptx
06-20
《人工智能英文版课件：Optimization methods.pptx》涵盖了优化方法在人工智能领域的应用，特别是对粒子群优化算法（PSO）的讲解。优化方法在AI中扮演着至关重要的角色，因为它们帮助寻找最佳解决方案，使得机器学习...
optimization-methods:ITMO优化方法课程家庭作业
04-01
课程的“optimization-methods-master”文件夹可能包含了各种作业和项目，涵盖了上述提到的优化方法。例如，可能有使用梯度下降法优化神经网络权重的案例，使用线性规划解决运输问题的实例，以及应用遗传算法或模拟...
吴恩达深度学习2021 C1作业
09-15
损失函数（Loss Functions）和优化算法（Optimization Algorithms）是深度学习中不可或缺的部分。常见的损失函数有均方误差（Mean Squared Error, MSE）和交叉熵损失（Cross-Entropy Loss），而优化器如梯度下降...
吴恩达 深度学习 编程作业（2-2）- Optimization Methods-附件资源
03-02
吴恩达 深度学习 编程作业（2-2）- Optimization Methods-附件资源
吴恩达第二课第二周编程作业Optimization Methods代码。
08-17
吴恩达第二课第二周编程作业Optimization Methods代码。
最优化方法：L1和L2正则化regularization
热门推荐
皮皮blog
08-18 4万+
http://blog.csdn.net/pipisorry/article/details/52108040机器学习和深度学习常用的规则化方法之一：L范数正则化（规格化）。一般来说，监督学习可以看做最小化下面的目标函数）：θ∗=arg⁡minθ1N∑i=1NL(yi,f(xi;θ))+λ 
深度学习（4）：训练集、验证集、测试集 以及偏差和方差
awake020
04-18 2838
在进行神经网络（以及各种机器学习模型）的训练中，我们需要对数据进行划分，以便于我们选择合适的超参数、评价模型的泛化能力。 训练集 我们利用训练集来进行参数训练（即前面提到的前向传播、反向传播、参数更新的过程）。 验证集 我们选取不同的超参数通过训练集训练出不同的模型。将这些模型应用在验证集上以选择最合适的超参数。 测试集 在确定好合适的超参数后，我们将模型应用在测试集上以判断模型的泛化能力。 要注...
深度学习（2）：logistic回归 梯度下降法
awake020
04-10 1217
二分类问题 我们经常会遇到各种各样的二分类问题，例如判断一张照片是猫或不是猫，判断一个西瓜是好瓜还是坏瓜。解决这类问题的一个很好的方法就是logistic回归。   线性回归 利用简单的线性回归可以进行二分类，这里我们简要介绍以下线性回归的思想，不做具体实现的阐述。 假定拥有的数据集为 m组（x，y）    x 为一组n维列向量，代表我们已知的n个属性    y 为标记，取值为0或1，代表其所属的...
深度学习（14）：对于贝叶斯误差的一点疑惑
awake020
04-26 1066
贝叶斯误差是我们学习模型的天花板，我们用贝叶斯误差和训练集误差进行比较来确定我们是否还拥有可避免偏差，是否有优化的空间，以及是否过拟合。 这里可以看出，只有承认训练集误差代表模型对真实数据的误差才能和贝叶斯误差进行比较。 然而对于训练集的误差我有些疑惑（下面我仍按猫识别问题进行分析）： 1.我们假设我们的训练集是完全正确的。那么我们的训练集误差的确代表了真实误差。可是由于贝叶斯误差的存在，我们用尽...
深度学习（8）：Momentum RMSprop Adam 学习率衰减
awake020
04-18 965
指数加权平均 对于一个序列a[1]，a[2]…a[3] 我们定义一个数组v[], 其中 v[i]= beta*v[i-1] + (1-beta)*a[i] 这个v就叫做a的指数加权平均值 可以直观的理解为v[i]代表着a[i]之前的1/（1-beta）组数据的平均值，例如beta为0.9时，v[n]近似代表着v[n-9]-v[n]的平均值 Momentum梯度下降法 对于简单的梯度下降法我们如下更...
Neural nets for vision
06-28
本资源是2012年计算机视觉和模式识别大会(CVPR)的一个深度学习教程，标题为"Neural nets for vision"，由Marc'Aurelio Ranzato主讲。教程聚焦于如何利用深度神经网络在视觉任务中构建对象识别系统，特别是关注end-to...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值