深度学习优化算法实现(Momentum, Adam)

最新推荐文章于 2024-08-06 15:30:00 发布
最新推荐文章于 2024-08-06 15:30:00 发布
阅读量2.9k 收藏 11
点赞数 2
分类专栏： 机器学习 文章标签： Momentum Adam 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012613903/article/details/99736536
版权

目录


除了常见的梯度下降法外，还有几种比较通用的优化算法；表现都优于梯度下降法。本文只记录完成吴恩达深度学习作业时遇到的Momentum和Adam算法，而且只有简要的代码。具体原理请看深度学习优化算法解析(Momentum, RMSProp, Adam),比较具体的说明了吴恩达版本的三种优化算法的讲述！

Momentum

初始化

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

更新参数

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)] += 
        -learning_rate * v['dW' + str(l + 1)]
        parameters['b' + str(l + 1)] += 
        -learning_rate * v['db' + str(l + 1)]
        ### END CODE HERE ###
    return parameters, v

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

更新参数

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
    # Initializing first moment estimate,python dictionary
    v_corrected = {} 
    # Initializing second moment estimate,python dictionary
    
    s_corrected = {} 
    # Perform Adam update on all parameters
    for l in range(L):
        ### 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 ###


        ### START CODE HERE ### (approx. 2 lines)
        v_corrected['dW' + str(l + 1)] = 
        v['dW' + str(l + 1)] / (1 - beta1 ** t)
        v_corrected['db' + str(l + 1)] = 
        v['db' + str(l + 1)] / (1 - beta1 ** t)
        ### END CODE HERE ###


        ### START CODE HERE ### (approx. 2 lines)
        s['dW' + str(l + 1)] = 
        beta2 * s['dW' + str(l + 1)] 
        + (1 - beta2) * np.square(grads['dW' + str(l + 1)])
        s['db' + str(l + 1)] = 
        beta2 * s['db' + str(l + 1)] 
        + (1 - beta2) * np.square(grads['db' + str(l + 1)]) 
        ### END CODE HERE ###

        ### START CODE HERE ### (approx. 2 lines)
        s_corrected['dW' + str(l + 1)] = 
        s['dW' + str(l + 1)] / (1 - beta2 ** t)
        s_corrected['db' + str(l + 1)] = 
        s['db' + str(l + 1)] / (1 - beta2 ** t)
        ### END CODE HERE ###

        ### START CODE HERE ### (approx. 2 lines)
        parameters['W' + str(l + 1)] += 
        -learning_rate * v_corrected['dW' + str(l + 1)] 
        / (np.sqrt(s['dW' + str(l + 1)]) + epsilon)
        parameters['b' + str(l + 1)] += 
        -learning_rate * v_corrected['db' + str(l + 1)] 
        / (np.sqrt(s['db' + str(l + 1)]) + epsilon)
        ### END CODE HERE ###
    return parameters, v, s
萝卜地里的兔子
关注
专栏目录
SGD,Adam,momentum等优化算法比较
Leokb24的博客
04-15 2895
文章目录SGD,Adam,momentum等优化算法比较一、最基本的优化算法1.SGD2.Momentum二、自适应参数的优化算法3.RMSprop4.Adam三、二阶近似的优化算法5.牛顿法及拟牛顿法 SGD,Adam,momentum等优化算法比较 1.选择哪种优化算法并没有达成共识 2.具有自适应学习率（以RMSProp 和AdaDelta 为代表）的算法族表现得相当鲁棒，不分伯仲，但没有...
adam优化算法_机器学习中的优化算法(2)-Momentum, RMSProp, AdaM
weixin_42553471的博客
12-31 525
郝曌骏：机器学习中的优化算法(1)​zhuanlan.zhihu.com第一篇介绍了这系列文章的思路,罗列了重要的数学记号,并讲了标准梯度下降法(GD, Gradient Descent)和Momentum机制.今天我们换个角度来解释Momentum,然后介绍RMSProp(Root Mean Square Propagation)和AdaM(Adaptive Moment Algo).换角度看M...
Momentum&Adam
yb564645735的博客
12-14 338
momentum&adam python实现
动量法(Momentum)
最新发布
LS_Ai的博客
08-06 999
动量法通过在梯度下降中引入动量项，能够加速收敛，并减少更新过程中的震荡。这使得动量法在许多优化问题中表现出色，尤其是在复杂函数的优化中。通过直观的图形展示，我们可以更好地理解动量法的优化过程和效果。
机器学习中几种优化算法的比较（SGD、Momentum、RMSProp、Adam）
weixin_34235105的博客
03-30 378
有关各种优化算法的详细算法流程和公式可以参考【这篇blog】，讲解比较清晰，这里说一下自己对他们之间关系的理解。 BGD 与 SGD 首先，最简单的 BGD 以整个训练集的梯度和作为更新方向，缺点是速度慢，一个 epoch 只能更新一次模型参数。 SGD 就是用来解决这个问题的，以每个样本的梯度作为更新方向，更新次数更频繁。但有两个缺点： 更新方向不稳定、波动很大。因为单个样本有很大的随机性，单...
adam优化_深度学习优化：Momentum、RMSProp 和 Adam
weixin_39911998的博客
11-27 407
【转】知乎在另一篇文章中，我们讨论了随机梯度下降的具体细节，以及如何解决诸如卡在局部极小值或鞍点上的问题。在这篇文章中，我们讨论另外一个困扰神经网络训练的问题，病态曲率。 虽然局部极小值和鞍点会阻碍我们的训练，但病态曲率会减慢训练的速度，以至于从事机器学习的人可能会认为搜索已经收敛到一个次优的极小值。让我们深入了解什么是病态曲率。病态曲率考虑以下损失曲线图。**病态曲率**如你所知，我们在进入一个...
Adam优化算法原理详解（吴恩达深度学习笔记）
01-06
在介绍Adam之前首先介绍一下momentum和RMSprop优化算法。 一、momentum 1、指数加权平均数 指数加权平均数不仅考虑了当前数值也涵盖了以前的数据对现在的影响。 解释指数加权平均值名称的由来： 指数加权平均值的...
收藏 _ 深度学习优化算法：从SGD到AdamW原理和代码解读1
08-04
通过理解和实现这些优化算法，我们可以更好地掌握深度学习模型的训练过程，选择适合特定任务的优化器。在PyTorch等深度学习框架中，可以方便地使用这些算法，例如`torch.optim.SGD`、`torch.optim.AdamW`等，进行...
基于Pytorch实现深度学习优化算法(Adagrad/RmsProp/Momentum/Adam)
qq_37053885的博客
08-12 1万+
以下介绍深度学习的主要几种参数更新的优化方法 1.Adagrad 使得学习率η∑ti=0(g2i)√η∑i=0t(gi2) \frac{\eta}{\sqrt{\sum_{i=0}^t(g_i^2)}}可以自适应，对于出现频率较低参数采用较大的α更新；相反，对于出现频率较高的参数采用较小的α更新。因此，Adagrad非常适合处理稀疏数据。 wt+1←wt−η∑ti=0(g2i)+ε‾‾‾‾‾...
深度学习优化算法研究.pdf
08-19
"深度学习优化算法研究" 深度学习是机器学习领域热门的研究方向，深度学习中的训练和优化算法也受到了较高的关注和研究，已成为人工智能发展的重要推动力。本文基于卷积神经网络的基本结构，介绍了网络训练中激活...
深度学习常用优化算法研究.pdf
08-18
"深度学习常用优化算法研究" 深度学习是人工智能领域的一个重要分支，已经在图像识别、自然语言理解、...关键词：深度学习、优化算法、梯度下降、随机梯度下降、Adam、RMSProp、Adagrad。 "深度学习常用优化算法研究
Momentum优化教程
11-13
ADS版图优化仿真手册，讲解了ADS从原理图到版图转换过程，并说明了如何在版图中队结构进行优化
SGD、Momentum、 AdaGrad、Adam
A496608119的博客
04-08 1997
目录 1.SGD 1.1 SGD的缺点 2. Momentum 3. AdaGrad 4. Adam 5 使用哪种更新方法呢 神经网络的学习的目的是找到使损失函数的值尽可能小的参数。这是寻找最优参数的问题，解决这个问题的过程称为最优化（optimization）。遗憾的是，神经网络的最优化问题非常难。 为了找到最优参数，我们将参数的梯度（导数）作为了线索。使用参数的梯度，沿梯度方向更新参数，并重复这个步骤多次，从而逐渐靠近最优参数，这个过程称为随机梯度下降法（stochastic gradie
深度学习入门——Mini-batch、Momentum与Adam算法
yasNing
03-15 2480
基于不同优化算法更新神经网络中的参数 学习记录自：deeplearning.ai-andrewNG-master 一、 优化算法概述 1.1 常用优化算法 在机器学习或深度学习中，一般采取梯度下降对参数进行优化更新，本文主要讨论Mini-Batch算法、Momentum算法、RMSprop以及Adam算法。 1.2 为什么要改进梯度下降 对于一个数据量适中的数据集而言，可以直接利用梯度下降或者随机梯度下降(Stochastic Gradient Descent)。此时在整个训练集进行梯度下降优化不会消耗
（转）深度学习中优化算法总结（momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam）
小C的博客
12-12 745
【时间】2018.12.12 【题目】深度学习中优化算法总结（momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam） 转载： 深度学习中优化方法——momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam Deep Learning 最优化方法之Momentum（动量）...
优化算法--momentum
zenglaoshi的博客
11-25 2327
momentum ​ 梯度下降或随机梯度下降都是目标函数在自变量当前位置下降最快的方向，然而，每次迭代都沿着最陡方向并且只考虑当前位置，会使得目标函数很容易陷入局部最小值和鞍点。 ​ 可以看到，同一位置上，目标函数在竖直方向（x2x_2x2​轴方向）比在水平方向（x1x_1x1​轴方向）的斜率的绝对值更大。因此，给定学习率，梯度下降迭代自变量时会使自变量在竖直方向比在水平方向移动幅度更大。那...
深度学习优化函数详解（4）-- momentum 动量法
热门推荐
史丹利复合田的博客
07-28 4万+
深度学习优化函数详解系列目录 深度学习优化函数详解（0）– 线性回归问题 深度学习优化函数详解（1）– Gradient Descent 梯度下降法 深度学习优化函数详解（2）– SGD 随机梯度下降 深度学习优化函数详解（3）– mini-batch SGD 小批量随机梯度下降 深度学习优化函数详解（4）– momentum 动量法 深度学习优化函数详解（5）– Neste...
【优化算法】Momentum
weixin_43872912的博客
03-25 1324
引入一个参数自然有它的原因，那这里引入动量的原因是什么： 类似这张图，垂直方向的斜率比水平方向的斜率大很多，会导致很多没必要的偏移量，加入一下动量因子可以减少偏移量。 动量法与SGD不同的点在于，它保存了历史的梯度，就像图上画的，B点实际下降方向是A点下降方向和B点下降方向的共同决定的。 # coding=utf-8 """ 基于小批量梯度下降来实现的Momentum（动量） 参考：https://blog.csdn.net/bvl10101111/article/details/72615621 作用
深度学习优化入门：Momentum、RMSProp 和 Adam
ZJQ的博客
08-25 1643
深度学习优化入门：Momentum、RMSProp 和 Adam
深度学习优化算法详解：从SGD到Adam
"该串讲主要讲解了优化算法在深度学习中的应用，涵盖了从基本的随机梯度下降(SGD)到更高级的优化算法，如动量法(Momentum)，牛顿法(NAG)，Adagrad，RMSProp/AdaDelta，Adam以及Nadam等。这些算法都是为了更有效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值