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

转x33g5p2x  于2022-05-30 转载在 其他  
字(6.1k)|赞(0)|评价(0)|浏览(436)

    之前在https://blog.csdn.net/fengbingchun/article/details/125018001 介绍过深度学习中的优化算法Adam，这里介绍下深度学习的另一种优化算法AdaMax。AdaMax与Adam来自于同一篇论文。论文名字为《ADAM: A METHOD FOR STOCHASTIC OPTIMIZATION》，论文地址：https://arxiv.org/pdf/1412.6980.pdf

    AdaMax：是梯度优化算法的扩展，基于无穷范数的Adam****的变体(a variant of Adam based on the infinity norm)。此算法对学习率的上限提供了一个更简单的范围，并可能对某些问题进行更有效的优化。如下图所示，截图来自：https://arxiv.org/pdf/1609.04747.pdf

    AdaMax与Adam区别：本质上前者是将L2范数推广到L-infinity****范数。AdaMax与Adam最终公式中仅分母的计算方式不同，AdaMax使用公式24，Adam使用公式20。

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

    1.在原有枚举类Optimizaiton的基础上新增AdaMax：

  1. enum class Optimization {
  2. 	BGD, // Batch Gradient Descent
  3. 	SGD, // Stochastic Gradient Descent
  4. 	MBGD, // Mini-batch Gradient Descent
  5. 	SGD_Momentum, // SGD with Momentum
  6. 	AdaGrad, // Adaptive Gradient
  7. 	RMSProp, // Root Mean Square Propagation
  8. 	Adadelta, // an adaptive learning rate method
  9. 	Adam, // Adaptive Moment Estimation
  10. 	AdaMax // a variant of Adam based on the infinity norm
  11. };

    2.calculate_gradient_descent函数：

  1. void LogisticRegression2::calculate_gradient_descent(int start, int end)
  2. {
  3. 	switch (optim_) {
  4. 		case Optimization::AdaMax: {
  5. 			int len = end - start;
  6. 			std::vector<float> m(feature_length_, 0.), u(feature_length_, 1e-8), mhat(feature_length_, 0.);
  7. 			std::vector<float> z(len, 0.), dz(len, 0.);
  8. 			float beta1t = 1.;
  9. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  10. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  11. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  13. 				beta1t *= beta1_;
  15. 				for (int j = 0; j < feature_length_; ++j) {
  16. 					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
  17. 					m[j] = beta1_ * m[j] + (1. - beta1_) * dw; // formula 19
  18. 					u[j] = std::max(beta2_ * u[j], std::fabs(dw)); // formula 24
  20. 					mhat[j] = m[j] / (1. - beta1t); // formula 20
  22. 					// Note: need to ensure than u[j] cannot be 0.
  23. 					// (1). u[j] is initialized to 1e-8, or
  24. 					// (2). if u[j] is initialized to 0., then u[j] adjusts to (u[j] + 1e-8)
  25. 					w_[j] = w_[j] - alpha_ * mhat[j] / u[j]; // formula 25
  26. 				}
  28. 				b_ -= (alpha_ * dz[x]);
  29. 			}
  30. 		}
  31. 			break;
  32. 		case Optimization::Adam: {
  33. 			int len = end - start;
  34. 			std::vector<float> m(feature_length_, 0.), v(feature_length_, 0.), mhat(feature_length_, 0.), vhat(feature_length_, 0.);
  35. 			std::vector<float> z(len, 0.), dz(len, 0.);
  36. 			float beta1t = 1., beta2t = 1.;
  37. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  38. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  39. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  41. 				beta1t *= beta1_;
  42. 				beta2t *= beta2_;
  44. 				for (int j = 0; j < feature_length_; ++j) {
  45. 					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
  46. 					m[j] = beta1_ * m[j] + (1. - beta1_) * dw; // formula 19
  47. 					v[j] = beta2_ * v[j] + (1. - beta2_) * (dw * dw); // formula 19
  49. 					mhat[j] = m[j] / (1. - beta1t); // formula 20
  50. 					vhat[j] = v[j] / (1. - beta2t); // formula 20
  52. 					w_[j] = w_[j] - alpha_ * mhat[j] / (std::sqrt(vhat[j]) + eps_); // formula 21
  53. 				}
  55. 				b_ -= (alpha_ * dz[x]);
  56. 			}
  57. 		}
  58. 			break;
  59. 		case Optimization::Adadelta: {
  60. 			int len = end - start;
  61. 			std::vector<float> g(feature_length_, 0.), p(feature_length_, 0.);
  62. 			std::vector<float> z(len, 0.), dz(len, 0.);
  63. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  64. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  65. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  67. 				for (int j = 0; j < feature_length_; ++j) {
  68. 					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
  69. 					g[j] = mu_ * g[j] + (1. - mu_) * (dw * dw); // formula 10
  71. 					float alpha = (eps_ + std::sqrt(p[j])) / (eps_ + std::sqrt(g[j]));
  72. 					float change = alpha * dw;
  73. 					p[j] = mu_ * p[j] +  (1. - mu_) * (change * change); // formula 15
  75. 					w_[j] = w_[j] - change;
  76. 				}
  78. 				b_ -= (eps_ * dz[x]);
  79. 			}
  80. 		}
  81. 			break;
  82. 		case Optimization::RMSProp: {
  83. 			int len = end - start;
  84. 			std::vector<float> g(feature_length_, 0.);
  85. 			std::vector<float> z(len, 0), dz(len, 0);
  86. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  87. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  88. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  90. 				for (int j = 0; j < feature_length_; ++j) {
  91. 					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
  92. 					g[j] = mu_ * g[j] + (1. - mu_) * (dw * dw); // formula 18
  93. 					w_[j] = w_[j] - alpha_ * dw / (std::sqrt(g[j]) + eps_);
  94. 				}
  96. 				b_ -= (alpha_ * dz[x]);
  97. 			}
  98. 		}
  99. 			break;
  100. 		case Optimization::AdaGrad: {
  101. 			int len = end - start;
  102. 			std::vector<float> g(feature_length_, 0.);
  103. 			std::vector<float> z(len, 0), dz(len, 0);
  104. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  105. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  106. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  108. 				for (int j = 0; j < feature_length_; ++j) {
  109. 					float dw = data_->samples[random_shuffle_[i]][j] * dz[x];
  110. 					g[j] += dw * dw;
  111. 					w_[j] = w_[j] - alpha_ * dw / (std::sqrt(g[j]) + eps_);
  112. 				}
  114. 				b_ -= (alpha_ * dz[x]);
  115. 			}
  116. 		}
  117. 			break;
  118. 		case Optimization::SGD_Momentum: {
  119. 			int len = end - start;
  120. 			std::vector<float> change(feature_length_, 0.);
  121. 			std::vector<float> z(len, 0), dz(len, 0);
  122. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  123. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  124. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  126. 				for (int j = 0; j < feature_length_; ++j) {
  127. 					float new_change = mu_ * change[j] - alpha_ * (data_->samples[random_shuffle_[i]][j] * dz[x]);
  128. 					w_[j] += new_change;
  129. 					change[j] = new_change;
  130. 				}
  132. 				b_ -= (alpha_ * dz[x]);
  133. 			}
  134. 		}
  135. 			break;
  136. 		case Optimization::SGD:
  137. 		case Optimization::MBGD: {
  138. 			int len = end - start;
  139. 			std::vector<float> z(len, 0), dz(len, 0);
  140. 			for (int i = start, x = 0; i < end; ++i, ++x) {
  141. 				z[x] = calculate_z(data_->samples[random_shuffle_[i]]);
  142. 				dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);
  144. 				for (int j = 0; j < feature_length_; ++j) {
  145. 					w_[j] = w_[j] - alpha_ * (data_->samples[random_shuffle_[i]][j] * dz[x]);
  146. 				}
  148. 				b_ -= (alpha_ * dz[x]);
  149. 			}
  150. 		}
  151. 			break;
  152. 		case Optimization::BGD:
  153. 		default: // BGD
  154. 			std::vector<float> z(m_, 0), dz(m_, 0);
  155. 			float db = 0.;
  156. 			std::vector<float> dw(feature_length_, 0.);
  157. 			for (int i = 0; i < m_; ++i) {
  158. 				z[i] = calculate_z(data_->samples[i]);
  159. 				o_[i] = calculate_activation_function(z[i]);
  160. 				dz[i] = calculate_loss_function_derivative(o_[i], data_->labels[i]);
  162. 				for (int j = 0; j < feature_length_; ++j) {
  163. 					dw[j] += data_->samples[i][j] * dz[i]; // dw(i)+=x(i)(j)*dz(i)
  164. 				}
  165. 				db += dz[i]; // db+=dz(i)
  166. 			}
  168. 			for (int j = 0; j < feature_length_; ++j) {
  169. 				dw[j] /= m_;
  170. 				w_[j] -= alpha_ * dw[j];
  171. 			}
  173. 			b_ -= alpha_*(db/m_);
  174. 	}
  175. }

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

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

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/fengbingchun/article/details/125032562

内容来源于网络，如有侵权，请联系作者删除！

AdaMax

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com