深度学习中的优化算法之Nadam

最新推荐文章于 2024-04-29 11:18:46 发布
最新推荐文章于 2024-04-29 11:18:46 发布
阅读量4.1k 收藏 12
点赞数 3
分类专栏： Deep Learning 文章标签： Nadam
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbingchun/article/details/125113842
版权

      之前在https://blog.csdn.net/fengbingchun/article/details/125018001 介绍过深度学习优化算法Adam，这里介绍下深度学习的另一种优化算法Nadam。

      Nadam：Nesterov-accelerated Adaptive Moment Estimation，梯度下降优化算法的扩展，是Adam(Adaptive Moment Estimation)和NAG(Nesterov Accelerated Gradient)两种算法的结合，可以提高优化算法的性能。如下图所示，截图来自：https://arxiv.org/pdf/1609.04747.pdf

     

       Nadam是Adam的扩展，添加了NAG，是一种改进的动量类型。

      Note：公式26对应于带动量的SGD中的公式4；公式27等价于公式26；公式28对应于NAG中的公式5；公式30对应于Adam中的公式19、20、21；公式31等价于公式30

      以下是与Nadam不同的代码片段：

      1. 在原有枚举类Optimization的基础上新增Nadam：

enum class Optimization {
	BGD, // Batch Gradient Descent
	SGD, // Stochastic Gradient Descent
	MBGD, // Mini-batch Gradient Descent
	SGD_Momentum, // SGD with Momentum
	AdaGrad, // Adaptive Gradient
	RMSProp, // Root Mean Square Propagation
	Adadelta, // an adaptive learning rate method
	Adam, // Adaptive Moment Estimation
	AdaMax, // a variant of Adam based on the infinity norm
	NAG, // Nesterov Accelerated Gradient
	Nadam // Nesterov-accelerated Adaptive Moment Estimation
};

      2. calculate_gradient_descent函数：

void LogisticRegression2::calculate_gradient_descent(int start, int end)
{
	switch (optim_) {
		case Optimization::Nadam: {
			int len = end - start;
			std::vector<float> m(feature_length_, 0.), v(feature_length_, 0.), mhat(feature_length_, 0.), vhat(feature_length_, 0.);
			std::vector<float> z(len, 0.), dz(len, 0.);
			float beta1t = 1., beta2t = 1.;
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				beta1t *= beta1_;
				beta2t *= beta2_;

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					m[j] = beta1_ * m[j] + (1. - beta1_) * dw; // formula 19
					v[j] = beta2_ * v[j] + (1. - beta2_) * (dw * dw); // formula 19

					mhat[j] = m[j] / (1. - beta1t); // formula 20
					vhat[j] = v[j] / (1. - beta2t); // formula 20

					w_[j] = w_[j] - alpha_ * (beta1_ * mhat[j] + (1. - beta1_) * dw / (1. - beta1t)) / (std::sqrt(vhat[j]) + eps_); // formula 33
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::NAG: {
			int len = end - start;
			std::vector<float> v(feature_length_, 0.);
			std::vector<float> z(len, 0), dz(len, 0);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z2(data_->samples[random_shuffle_[i]], v);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					v[j] = mu_ * v[j] + alpha_ * dw; // formula 5
					w_[j] = w_[j] - v[j];
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::AdaMax: {
			int len = end - start;
			std::vector<float> m(feature_length_, 0.), u(feature_length_, 1e-8), mhat(feature_length_, 0.);
			std::vector<float> z(len, 0.), dz(len, 0.);
			float beta1t = 1.;
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				beta1t *= beta1_;

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					m[j] = beta1_ * m[j] + (1. - beta1_) * dw; // formula 19
					u[j] = std::max(beta2_ * u[j], std::fabs(dw)); // formula 24

					mhat[j] = m[j] / (1. - beta1t); // formula 20

					// Note: need to ensure than u[j] cannot be 0.
					// (1). u[j] is initialized to 1e-8, or
					// (2). if u[j] is initialized to 0., then u[j] adjusts to (u[j] + 1e-8)
					w_[j] = w_[j] - alpha_ * mhat[j] / u[j]; // formula 25
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::Adam: {
			int len = end - start;
			std::vector<float> m(feature_length_, 0.), v(feature_length_, 0.), mhat(feature_length_, 0.), vhat(feature_length_, 0.);
			std::vector<float> z(len, 0.), dz(len, 0.);
			float beta1t = 1., beta2t = 1.;
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				beta1t *= beta1_;
				beta2t *= beta2_;

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					m[j] = beta1_ * m[j] + (1. - beta1_) * dw; // formula 19
					v[j] = beta2_ * v[j] + (1. - beta2_) * (dw * dw); // formula 19

					mhat[j] = m[j] / (1. - beta1t); // formula 20
					vhat[j] = v[j] / (1. - beta2t); // formula 20

					w_[j] = w_[j] - alpha_ * mhat[j] / (std::sqrt(vhat[j]) + eps_); // formula 21
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::Adadelta: {
			int len = end - start;
			std::vector<float> g(feature_length_, 0.), p(feature_length_, 0.);
			std::vector<float> z(len, 0.), dz(len, 0.);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					g[j] = mu_ * g[j] + (1. - mu_) * (dw * dw); // formula 10

					//float alpha = std::sqrt(p[j] + eps_) / std::sqrt(g[j] + eps_);
					float change = -std::sqrt(p[j] + eps_) / std::sqrt(g[j] + eps_) * dw; // formula 17
					w_[j] = w_[j] + change;

					p[j] = mu_ * p[j] +  (1. - mu_) * (change * change); // formula 15
				}

				b_ -= (eps_ * dz[x]);
			}
		}
			break;
		case Optimization::RMSProp: {
			int len = end - start;
			std::vector<float> g(feature_length_, 0.);
			std::vector<float> z(len, 0), dz(len, 0);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					g[j] = mu_ * g[j] + (1. - mu_) * (dw * dw); // formula 18
					w_[j] = w_[j] - alpha_ * dw / std::sqrt(g[j] + eps_);
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::AdaGrad: {
			int len = end - start;
			std::vector<float> g(feature_length_, 0.);
			std::vector<float> z(len, 0), dz(len, 0);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					g[j] += dw * dw;
					w_[j] = w_[j] - alpha_ * dw / std::sqrt(g[j] + eps_); // formula 8
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::SGD_Momentum: {
			int len = end - start;
			std::vector<float> v(feature_length_, 0.);
			std::vector<float> z(len, 0), dz(len, 0);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					v[j] = mu_ * v[j] + alpha_ * dw; // formula 4
					w_[j] = w_[j] - v[j];
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::SGD:
		case Optimization::MBGD: {
			int len = end - start;
			std::vector<float> z(len, 0), dz(len, 0);
			for (int i = start, x = 0; i < end; ++i, ++x) {
				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);

				for (int j = 0; j < feature_length_; ++j) {
					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
					w_[j] = w_[j] - alpha_ * dw;
				}

				b_ -= (alpha_ * dz[x]);
			}
		}
			break;
		case Optimization::BGD:
		default: // BGD
			std::vector<float> z(m_, 0), dz(m_, 0);
			float db = 0.;
			std::vector<float> dw(feature_length_, 0.);
			for (int i = 0; i < m_; ++i) {
				z[i] = calculate_z(data_->samples[i]);
				o_[i] = calculate_activation_function(z[i]);
				dz[i] = calculate_loss_function_derivative(o_[i], data_->labels[i]);

				for (int j = 0; j < feature_length_; ++j) {
					dw[j] += data_->samples[i][j] * dz[i]; // dw(i)+=x(i)(j)*dz(i)
				}
				db += dz[i]; // db+=dz(i)
			}

			for (int j = 0; j < feature_length_; ++j) {
				dw[j] /= m_;
				w_[j] -= alpha_ * dw[j];
			}

			b_ -= alpha_*(db/m_);
	}
}

      执行结果如下图所示：测试函数为test_logistic_regression2_gradient_descent，多次执行每种配置，最终结果都相同。图像集使用MNIST，其中训练图像总共10000张，0和1各5000张，均来自于训练集；预测图像总共1800张，0和1各900张，均来自于测试集。Nadam和Adam配置参数相同的情况下，即学习率为0.001，beta1为0.8，beta2为0.8888，eps为1e-8，Adam耗时29秒，Nadam耗时25秒，它们的识别率均为100%

      GitHub： https://github.com/fengbingchun/NN_Test

fengbingchun
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度学习最全优化方法总结比较（SGD，Adagrad，Adadelta，Adam，Adamax，Nadam）
余昌黔|书山有路
08-24 6万+
前言（标题不能再中二了）本文仅对一些常见的优化方法进行直观介绍和简单的比较，各种优化方法的详细内容及公式只好去认真啃论文了，在此我就不赘述了。SGD此处的SGD指mini-batch gradient descent，关于batch gradient descent, stochastic gradient descent, 以及 mini-batch gradient descent的具体区别就不
十三、机器学习进阶知识：神经网络之反向传播算法（自适应矩估计算法Adam变形形式之Adamax、Nadam）
weixin_42051846的博客
04-17 1386
本文主要介绍了反向传播算法中的自适应矩估计算法（Adam）的两种变形形式Adamax和Nadam，同时以神经网络数据预测为例对它的实现过程进行了说明，通俗易懂，适合新手学习，附源码及实验数据集。
不同算法的差异SGD/AdaGrad/AdaDelta/Adam/Nadam
u010451638的博客
10-16 1799
一、准备知识 指数加权平均 指数加权平均值又称指数加权移动平均值，局部平均值，移动平均值。加权平均这个概念都很熟悉，即根据各个元素所占权重计算平均值。指数加权平均中的指数表示各个元素所占权重呈指数分布。 mini-batch梯度下降法 在实际应用中，由于样本数量庞大，训练数据上百万是很常见的事。如果每执行一次梯度下降就遍历整个训练样本将会耗费大量的计算机资源。在所有样本中随机抽取一部分(mini-batch)样本，抽取的样本的分布规律与原样本基本相同，事实发现，实际训练中使用mini-batch梯度下降法可
各种优化器及其优缺点（SGD,RMSProp,Adam及其变种）
最新发布
samoyan的博客,记录技术成长~
04-29 2103
其中，θ_t是第t步的参数，α是学习率，∇f(θ_{t-1})是损失函数在第t-1步的梯度，r_t是第t步的平方梯度的移动平均值，β是衰减系数，ε是防止除0错误的小常数。其中，m_t和v_t分别是一阶矩和二阶矩的指数移动平均值，β1和β2是衰减系数，α是学习率，λ是权重衰减系数，ε是防止除0错误的小常数。其中，θ_t是第t步的参数，α是学习率，∇f(θ_{t-1})是损失函数在第t-1步的梯度，v_t是第t步的速度，γ是动量参数。动量优化的另一个缺点是可能会导致优化过程在某些方向上过快，从而跳过最优解。
深度学习优化算法大全系列7:NAdam，算法选择，调参
bitcarmanlee的博客
01-14 4901
1.NAdam集大成 前面我们讲Adam的时候，提到Adam是Adaptive+Momentum。更前面的时候，我们还提到Nesterov，如果把Nesterov跟Adam结果，就是我们最后的集大成者NAdam。 class Nadam(Optimizer): """Nesterov Adam optimizer. Much like Adam is essentially RMSprop with momentum, Nadam is Adam RMSprop with Nesterov m
Nadam优化算法公式推导（涉及Netsterov，Adam，Momentum）
灰灰渔渔爱吃鱼
03-29 779
原论文：INCORPORATING NESTEROV MOMENTUM INTO ADAM https://openreview.net/pdf?id=OM0jvwB8jIp57ZJjtNEZ
从零开始使用Nadam进行梯度下降优化
Together_CZ的博客
03-19 2128
【翻译自 ： Gradient Descent Optimization With Nadam From Scratch】 【说明：Jason BrownleePhD大神的文章个人很喜欢，所以闲暇时间里会做一点翻译和学习实践的工作，这里是相应工作的实践记录，希望能帮到有需要的人！】 梯度下降是一种优化算法，遵循目标函数的负梯度以定位函数的最小值。 梯度下降的局限性在于，如果梯度变为平坦或大曲率，搜索的进度可能会减慢。可以将动量添...
[AI算法]：优化算法总结（区别及联系）SGD Momentum NAG Aadagrad RMSprop AadaDelta Adam Nadam
Bin_Dut的博客
04-05 1430
文章是最近整理的一些深度学习优化算法总结，具体参考文献见文章末尾： 刚刚开始接触优化算法，林林总总，认识总是很浅薄，但是当你拿过来看的时候，发现从刚刚开始的SGD到现在的adam、Nadam等，原理上其实是相通的。 算法基本框架 图中的一阶动量和二阶动量分别是历史梯度的一阶导数函数和二阶导数函数。 SGD梯度下降 随机梯度下降，作为最为基础的优化算法，以样本数据的负梯度方向作为优化方向，在深度学习...
madam:Madam优化器的Pytorch和Jax代码
05-23
Optimister女士 ···· · 入门 Jax： 。 Pytorch：获取并将其放置在您的项目目录... 该算法收敛到一个解决方案，该解决方案在真实解决方案周围“抖动”，这时应该降低学习速率。 我们没有对g_bound进行太多实验，
算法作业_算法_回文序列_
10-01
5. Manacher's Algorithm（曼哈顿算法）：这是一类优化的回文检测算法，它可以在线性时间内完成，且只使用线性空间。该算法利用了回文的对称性，避免了不必要的重复计算，提高了效率。 从给出的文件名来看，"Huiwen...
编程之法面试和算法心得1
08-03
除了上述章节，本书还涵盖了数组、树、查找匹配、动态规划、海量数据处理以及机器学习等多个领域的知识点，旨在通过具体的编程问题和算法来提升面试和实际编程能力。每个章节都提供了习题帮助读者巩固理解，并强调了...
算法题自己的理解1
08-08
这里我们将深入探讨四个算法相关的问题，它们分别是：判断字符串是否为回文、数组去重、找到字符串中出现最多的字符以及两种排序算法——冒泡排序和快速排序。 1. **判断字符串是否回文** 回文是指正读反读都能读...
前端js 算法题目实例解析（1）
01-07
在前端开发中，JavaScript语言是不可或缺的一部分，而算法能力则是衡量一个前端工程师技术水平的重要标准。以下是对给定的几个算法题目实例的详细解析： 1. **数组小于0放左大对于0放右** 这个题目主要考察数组操作...
深度学习基础模型算法原理及编程实现--10.优化方法：从梯度下降到NAdam
drilistbox的博客
05-30 2180
文章列表 1.深度学习基础模型算法原理及编程实现–01.感知机. 2.深度学习基础模型算法原理及编程实现–02.线性单元 . 3.深度学习基础模型算法原理及编程实现–03.全链接 . 4.深度学习基础模型算法原理及编程实现–04.改进神经网络的方法 . 5.深度学习基础模型算法原理及编程实现–05.卷积神经网络. 6.深度学习基础模型算法原理及编程实现–06.循环神经网络. 9.深度...
nadam优化器
studyvcmfc的专栏
08-26 3920
https://blog.csdn.net/qq_42109740/article/details/105401197
梯度下降（二）：自适应梯度(AdaGrad)、均方根传递(RMSProp)、自适应增量(AdaDelta)、自适应矩估计(Adam)、Nesterov自适应矩估计(Nadam)
weixin_43290523的博客
04-26 8084
梯度下降（二）：自适应学习率（AdaGrad）、均方根传递（RMSProp）、自适应增量（AdaDelta）、自适应性矩估计(Adam）Nesterov自适应性矩估计（Nadam）前言自适应梯度（AdaGrad / Adaptive Gradient）均方根传递（RMSProp / Root Mean Square Propagation）自适应增量（AdaDelta）自适应矩估计（Adam /...
深度学习优化方法总结比较（SGD，Adagrad，Adadelta，Adam，Adamax，Nadam）
qq_29462849的博客
12-14 2568
作者丨ycszen来源｜https://zhuanlan.zhihu.com/p/22252270编辑丨极市平台导读本文仅对一些常见的优化方法进行直观介绍和简单的比较。前言本文仅对一些...
C++元编程——nadam优化的bp神经网络
Dr_Jack的博客
11-07 327
使用C++元编程实现了矩阵运算，并在此基础上在之前的bp神经网络程序中做了一些优化，同时实现了nadam，并进行了测试，发现nadam确实会比adam快一些。
编写一个Python函数，检查传递的字符中是杏是回文结构。 注意:回文结构是一个单司、短语或序列，我读起来与读前相同，例如，madam或nurses run。
06-03
好的，以下是一个检查回文字符串的 Python 函数： ```python def is_palindrome(s): s = s.lower() s = ''.join(c for c in s if c.isalnum()) return s == s[::-1] ``` 这个函数的思路是，首先将输入的字符串转换为小写字母，并且只保留其中的字母和数字。然后，判断这个字符串是否与它的反向字符串相等，如果相等，则说明它是一个回文字符串。 例如，对于输入 "A man, a plan, a canal: Panama"，该函数将返回 True。 希望这个函数能够满足你的需求，如果有其他问题可以继续问我。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值