从零开始使用 Nadam 进行梯度下降优化

十三、机器学习进阶知识:神经网络之反向传播算法(自适应矩估计算法Adam变形形式之Adamax、Nadam) 本文主要介绍了反向传播算法中的自适应矩估计算法(Adam)的两种变形形式Adamax和Nadam,同时以神经网络数据预测为例对它的实现过程进行了说明,通俗易懂,适合新手学习,附源码及实验数据集。 阅读详情

梯度下降是一种优化算法,遵循目标函数的负梯度以定位函数的最小值。

梯度下降的局限性在于,如果梯度变为平坦或大曲率,搜索的进度可能会减慢。可以将动量添加到梯度下降中,该下降合并了一些惯性以进行更新。可以通过合并预计的新位置而非当前位置的梯度(称为Nesterov的加速梯度(NAG)或Nesterov动量)来进一步改善此效果。

梯度下降的另一个限制是,所有输入变量都使用单个步长(学习率)。对梯度下降的扩展,如自适应运动估计(Adam)算法,该算法对每个输入变量使用单独的步长,但可能会导致步长迅速减小到非常小的值。Nesterov加速的自适应矩估计或Nadam是Adam算法的扩展,该算法结合了Nesterov动量,可以使优化算法具有更好的性能。

在本教程中,您将发现如何从头开始使用Nadam进行梯度下降优化。完成本教程后,您将知道:

  • 梯度下降是一种优化算法,它使用目标函数的梯度来导航搜索空间。

  • 纳丹(Nadam)是亚当(Adam)版本的梯度下降的扩展,其中包括了内斯特罗夫的动量。

  • 如何从头开始实现Nadam优化算法并将其应用于目标函数并评估结果。

教程概述

本教程分为三个部分:他们是:

  • 梯度下降

  • Nadam优化算法

  • 娜达姆(Nadam)的梯度下降

    • 二维测试问题

    • Nadam的梯度下降优化

    • 可视化的Nadam优化

梯度下降

梯度下降是一种优化算法。它在技术上称为一阶优化算法,因为它明确利用了目标目标函数的一阶导数。

一阶导数,或简称为“导数”,是目标函数在特定点(例如,点)上的变化率或斜率。用于特定输入。

如果目标函数采用多个输入变量,则将其称为多元函数,并且可以将输入变量视为向量。反过来,多元目标函数的导数也可以视为向量,通常称为梯度。

梯度:多元目标函数的一阶导数。

对于特定输入,导数或梯度指向目标函数最陡峭的上升方向。梯度下降是指一种最小化优化算法,该算法遵循目标函数的下坡梯度负值来定位函数的最小值。

梯度下降算法需要一个正在优化的目标函数和该目标函数的导数函数。目标函数f()返回给定输入集合的分数,导数函数f'()给出给定输入集合的目标函数的导数。梯度下降算法需要问题中的起点(x),例如输入空间中的随机选择点。

假设我们正在最小化目标函数,然后计算导数并在输入空间中采取一步,这将导致目标函数下坡运动。首先通过计算输入空间中要移动多远的距离来进行下坡运动,计算方法是将步长(称为alpha或学习率)乘以梯度。然后从当前点减去该值,以确保我们逆梯度移动或向下移动目标函数。

x(t)= x(t-1)–step* f'(x(t))

在给定点的目标函数越陡峭,梯度的大小越大,反过来,在搜索空间中采取的步伐也越大。使用步长超参数来缩放步长的大小。

步长:超参数,用于控制算法每次迭代相对于梯度在搜索空间中移动多远。

如果步长太小,则搜索空间中的移动将很小,并且搜索将花费很长时间。如果步长太大,则搜索可能会在搜索空间附近反弹并跳过最优值。

现在我们已经熟悉了梯度下降优化算法,接下来让我们看一下Nadam算法。

Nadam优化算法

Nesterov加速的自适应动量估计或Nadam算法是对自适应运动估计(Adam)优化算法的扩展,添加了Nesterov的加速梯度(NAG)或Nesterov动量,这是一种改进的动量。更广泛地讲,Nadam算法是对梯度下降优化算法的扩展。Timothy Dozat在2016年的论文“将Nesterov动量整合到Adam中”中描述了该算法。尽管论文的一个版本是在2015年以同名斯坦福项目报告的形式编写的。动量将梯度的指数衰减移动平均值(第一矩)添加到梯度下降算法中。这具有消除嘈杂的目标函数和提高收敛性的影响。Adam是梯度下降的扩展,它增加了梯度的第一和第二矩,并针对正在优化的每个参数自动调整学习率。NAG是动量的扩展,其中动量的更新是使用对参数的预计更新量而不是实际当前变量值的梯度来执行的。在某些情况下,这样做的效果是在找到最佳位置时减慢了搜索速度,而不是过冲。

纳丹(Nadam)是对亚当(Adam)的扩展,它使用NAG动量代替经典动量。让我们逐步介绍该算法的每个元素。Nadam使用衰减步长(alpha)和一阶矩(mu)超参数来改善性能。为了简单起见,我们暂时将忽略此方面,并采用恒定值。首先,对于搜索中要优化的每个参数,我们必须保持梯度的第一矩和第二矩,分别称为m和n。在搜索开始时将它们初始化为0.0。

m = 0

n = 0

该算法在从t = 1开始的时间t内迭代执行,并且每次迭代都涉及计算一组新的参数值x,例如。从x(t-1)到x(t)。如果我们专注于更新一个参数,这可能很容易理解该算法,该算法概括为通过矢量运算来更新所有参数。首先,计算当前时间步长的梯度(偏导数)。

g(t)= f'(x(t-1))

接下来,使用梯度和超参数“ mu”更新第一时刻。

m(t)=mu* m(t-1)+(1 –mu)* g(t)

然后使用“ nu”超参数更新第二时刻。

n(t)= nu * n(t-1)+(1 – nu)* g(t)^ 2

接下来,使用Nesterov动量对第一时刻进行偏差校正。

mhat =(mu * m(t)/(1 – mu))+((1 – mu)* g(t)/(1 – mu))

然后对第二个时刻进行偏差校正。注意:偏差校正是Adam的一个方面,它与在搜索开始时将第一时刻和第二时刻初始化为零这一事实相反。

nhat = nu * n(t)/(1 – nu)

最后,我们可以为该迭代计算参数的值。

x(t)= x(t-1)– alpha /(sqrt(nhat)+ eps)* mhat

其中alpha是步长(学习率)超参数,sqrt()是平方根函数,eps(epsilon)是一个较小的值,如1e-8,以避免除以零误差。

回顾一下,该算法有三个超参数。他们是:

alpha:初始步长(学习率),典型值为0.002。
mu:第一时刻的衰减因子(Adam中的beta1),典型值为0.975。
nu:第二时刻的衰减因子(Adam中的beta2),典型值为0.999。

就是这样。接下来,让我们看看如何在Python中从头开始实现该算法。

娜达姆(Nadam)的梯度下降

在本节中,我们将探索如何使用Nadam动量实现梯度下降优化算法。

二维测试问题

首先,让我们定义一个优化函数。我们将使用一个简单的二维函数,该函数将每个维的输入平方,并定义有效输入的范围(从-1.0到1.0)。下面的Objective()函数实现了此功能

# objective function
def objective(x, y):
 return x**2.0 + y**2.0

我们可以创建数据集的三维图,以了解响应面的曲率。下面列出了绘制目标函数的完整示例。

# 3d plot of the test function
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
 
# objective function
def objective(x, y):
 return x**2.0 + y**2.0
 
# define range for input
r_min, r_max = -1.0, 1.0
# sample input range uniformly at 0.1 increments
xaxis = arange(r_min, r_max, 0.1)
yaxis = arange(r_min, r_max, 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a surface plot with the jet color scheme
figure = pyplot.figure()
axis = figure.gca(projection='3d')
axis.plot_surface(x, y, results, cmap='jet')
# show the plot
pyplot.show()

运行示例将创建目标函数的三维表面图。我们可以看到全局最小值为f(0,0)= 0的熟悉的碗形状。

我们还可以创建函数的二维图。这在以后要绘制搜索进度时会很有帮助。下面的示例创建目标函数的轮廓图。

# contour plot of the test function
from numpy import asarray
from numpy import arange
from numpy import meshgrid
from matplotlib import pyplot
 
# objective function
def objective(x, y):
 return x**2.0 + y**2.0
 
# define range for input
bounds = asarray([[-1.0, 1.0], [-1.0, 1.0]])
# sample input range uniformly at 0.1 increments
xaxis = arange(bounds[0,0], bounds[0,1], 0.1)
yaxis = arange(bounds[1,0], bounds[1,1], 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a filled contour plot with 50 levels and jet color scheme
pyplot.contourf(x, y, results, levels=50, cmap='jet')
# show the plot
pyplot.show()

运行示例将创建目标函数的二维轮廓图。我们可以看到碗的形状被压缩为以颜色渐变显示的轮廓。我们将使用该图来绘制在搜索过程中探索的特定点。

现在我们有了一个测试目标函数,让我们看一下如何实现Nadam优化算法。

Nadam的梯度下降优化

我们可以将Nadam的梯度下降应用于测试问题。首先,我们需要一个函数来计算此函数的导数。

x ^ 2的导数在每个维度上均为x * 2。

f(x)= x ^ 2
f'(x)= x * 2

derived()函数在下面实现了这一点。

# derivative of objective function
def derivative(x, y):
 return asarray([x * 2.0, y * 2.0])

接下来,我们可以使用Nadam实现梯度下降优化。首先,我们可以选择问题范围内的随机点作为搜索的起点。假定我们有一个数组,该数组定义搜索范围,每个维度一行,并且第一列定义最小值,第二列定义维度的最大值。

# generate an initial point
x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] - bounds[:, 0])
score = objective(x[0], x[1])

接下来,我们需要初始化力矩矢量。

# initialize decaying moving averages
m = [0.0 for _ in range(bounds.shape[0])]
n = [0.0 for _ in range(bounds.shape[0])]

然后,我们运行由“ n_iter”超参数定义的算法的固定迭代次数。

...
# run iterations of gradient descent
for t in range(n_iter):
 ...

第一步是计算当前参数集的导数。

...
# calculate gradient g(t)
g = derivative(x[0], x[1])

接下来,我们需要执行Nadam更新计算。为了提高可读性,我们将使用命令式编程样式来一次执行一个变量的这些计算。在实践中,我建议使用NumPy向量运算以提高效率。

...
# build a solution one variable at a time
for i in range(x.shape[0]):
 ...

首先,我们需要计算力矩矢量。

# m(t) = mu * m(t-1) + (1 - mu) * g(t)
m[i] = mu * m[i] + (1.0 - mu) * g[i]

然后是第二个矩向量。

# nhat = nu * n(t) / (1 - nu)
nhat = nu * n[i] / (1.0 - nu)
# n(t) = nu * n(t-1) + (1 - nu) * g(t)^2
n[i] = nu * n[i] + (1.0 - nu) * g[i]**2

然后是经过偏差校正的内斯特罗夫动量。

# mhat = (mu * m(t) / (1 - mu)) + ((1 - mu) * g(t) / (1 - mu))
mhat = (mu * m[i] / (1.0 - mu)) + ((1 - mu) * g[i] / (1.0 - mu))

偏差校正的第二时刻。

# nhat = nu * n(t) / (1 - nu)
nhat = nu * n[i] / (1.0 - nu)

最后更新参数。

# x(t) = x(t-1) - alpha / (sqrt(nhat) + eps) * mhat
x[i] = x[i] - alpha / (sqrt(nhat) + eps) * mhat

然后,针对要优化的每个参数重复此操作。在迭代结束时,我们可以评估新的参数值并报告搜索的性能。

# evaluate candidate point
score = objective(x[0], x[1])
# report progress
print('>%d f(%s) = %.5f' % (t, x, score))

我们可以将所有这些结合到一个名为nadam()的函数中,该函数采用目标函数和派生函数的名称以及算法超参数,并返回在搜索及其评估结束时找到的最佳解决方案。

# gradient descent algorithm with nadam
def nadam(objective, derivative, bounds, n_iter, alpha, mu, nu, eps=1e-8):
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] - bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize decaying moving averages
 m = [0.0 for _ in range(bounds.shape[0])]
 n = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent
 for t in range(n_iter):
  # calculate gradient g(t)
  g = derivative(x[0], x[1])
  # build a solution one variable at a time
  for i in range(bounds.shape[0]):
   # m(t) = mu * m(t-1) + (1 - mu) * g(t)
   m[i] = mu * m[i] + (1.0 - mu) * g[i]
   # n(t) = nu * n(t-1) + (1 - nu) * g(t)^2
   n[i] = nu * n[i] + (1.0 - nu) * g[i]**2
   # mhat = (mu * m(t) / (1 - mu)) + ((1 - mu) * g(t) / (1 - mu))
   mhat = (mu * m[i] / (1.0 - mu)) + ((1 - mu) * g[i] / (1.0 - mu))
   # nhat = nu * n(t) / (1 - nu)
   nhat = nu * n[i] / (1.0 - nu)
   # x(t) = x(t-1) - alpha / (sqrt(nhat) + eps) * mhat
   x[i] = x[i] - alpha / (sqrt(nhat) + eps) * mhat
  # evaluate candidate point
  score = objective(x[0], x[1])
  # report progress
  print('>%d f(%s) = %.5f' % (t, x, score))
 return [x, score]

然后,我们可以定义函数和超参数的界限,并调用函数执行优化。在这种情况下,我们将运行该算法进行50次迭代,初始alpha为0.02,μ为0.8,nu为0.999,这是经过一点点反复试验后发现的。

# seed the pseudo random number generator
seed(1)
# define range for input
bounds = asarray([[-1.0, 1.0], [-1.0, 1.0]])
# define the total iterations
n_iter = 50
# steps size
alpha = 0.02
# factor for average gradient
mu = 0.8
# factor for average squared gradient
nu = 0.999
# perform the gradient descent search with nadam
best, score = nadam(objective, derivative, bounds, n_iter, alpha, mu, nu)

运行结束时,我们将报告找到的最佳解决方案。

# summarize the result
print('Done!')
print('f(%s) = %f' % (best, score))

综合所有这些,下面列出了适用于我们的测试问题的Nadam梯度下降的完整示例。

# gradient descent optimization with nadam for a two-dimensional test function
from math import sqrt
from numpy import asarray
from numpy.random import rand
from numpy.random import seed
 
# objective function
def objective(x, y):
 return x**2.0 + y**2.0
 
# derivative of objective function
def derivative(x, y):
 return asarray([x * 2.0, y * 2.0])
 
# gradient descent algorithm with nadam
def nadam(objective, derivative, bounds, n_iter, alpha, mu, nu, eps=1e-8):
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] - bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize decaying moving averages
 m = [0.0 for _ in range(bounds.shape[0])]
 n = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent
 for t in range(n_iter):
  # calculate gradient g(t)
  g = derivative(x[0], x[1])
  # build a solution one variable at a time
  for i in range(bounds.shape[0]):
   # m(t) = mu * m(t-1) + (1 - mu) * g(t)
   m[i] = mu * m[i] + (1.0 - mu) * g[i]
   # n(t) = nu * n(t-1) + (1 - nu) * g(t)^2
   n[i] = nu * n[i] + (1.0 - nu) * g[i]**2
   # mhat = (mu * m(t) / (1 - mu)) + ((1 - mu) * g(t) / (1 - mu))
   mhat = (mu * m[i] / (1.0 - mu)) + ((1 - mu) * g[i] / (1.0 - mu))
   # nhat = nu * n(t) / (1 - nu)
   nhat = nu * n[i] / (1.0 - nu)
   # x(t) = x(t-1) - alpha / (sqrt(nhat) + eps) * mhat
   x[i] = x[i] - alpha / (sqrt(nhat) + eps) * mhat
  # evaluate candidate point
  score = objective(x[0], x[1])
  # report progress
  print('>%d f(%s) = %.5f' % (t, x, score))
 return [x, score]
 
# seed the pseudo random number generator
seed(1)
# define range for input
bounds = asarray([[-1.0, 1.0], [-1.0, 1.0]])
# define the total iterations
n_iter = 50
# steps size
alpha = 0.02
# factor for average gradient
mu = 0.8
# factor for average squared gradient
nu = 0.999
# perform the gradient descent search with nadam
best, score = nadam(objective, derivative, bounds, n_iter, alpha, mu, nu)
print('Done!')
print('f(%s) = %f' % (best, score))

运行示例将优化算法和Nadam应用于我们的测试问题,并报告算法每次迭代的搜索性能。

注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。

在这种情况下,我们可以看到在大约44次搜索迭代后找到了接近最佳的解决方案,输入值接近0.0和0.0,评估为0.0。

>40 f([ 5.07445337e-05 -3.32910019e-03]) = 0.00001
>41 f([-1.84325171e-05 -3.00939427e-03]) = 0.00001
>42 f([-6.78814472e-05 -2.69839367e-03]) = 0.00001
>43 f([-9.88339249e-05 -2.40042096e-03]) = 0.00001
>44 f([-0.00011368 -0.00211861]) = 0.00000
>45 f([-0.00011547 -0.00185511]) = 0.00000
>46 f([-0.0001075 -0.00161122]) = 0.00000
>47 f([-9.29922627e-05 -1.38760991e-03]) = 0.00000
>48 f([-7.48258406e-05 -1.18436586e-03]) = 0.00000
>49 f([-5.54299505e-05 -1.00116899e-03]) = 0.00000
Done!
f([-5.54299505e-05 -1.00116899e-03]) = 0.000001

可视化的Nadam优化

我们可以在域的等高线上绘制Nadam搜索的进度。这可以为算法迭代过程中的搜索进度提供直观的认识。我们必须更新nadam()函数以维护在搜索过程中找到的所有解决方案的列表,然后在搜索结束时返回此列表。下面列出了具有这些更改的功能的更新版本。

# gradient descent algorithm with nadam
def nadam(objective, derivative, bounds, n_iter, alpha, mu, nu, eps=1e-8):
 solutions = list()
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] - bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize decaying moving averages
 m = [0.0 for _ in range(bounds.shape[0])]
 n = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent
 for t in range(n_iter):
  # calculate gradient g(t)
  g = derivative(x[0], x[1])
  # build a solution one variable at a time
  for i in range(bounds.shape[0]):
   # m(t) = mu * m(t-1) + (1 - mu) * g(t)
   m[i] = mu * m[i] + (1.0 - mu) * g[i]
   # n(t) = nu * n(t-1) + (1 - nu) * g(t)^2
   n[i] = nu * n[i] + (1.0 - nu) * g[i]**2
   # mhat = (mu * m(t) / (1 - mu)) + ((1 - mu) * g(t) / (1 - mu))
   mhat = (mu * m[i] / (1.0 - mu)) + ((1 - mu) * g[i] / (1.0 - mu))
   # nhat = nu * n(t) / (1 - nu)
   nhat = nu * n[i] / (1.0 - nu)
   # x(t) = x(t-1) - alpha / (sqrt(nhat) + eps) * mhat
   x[i] = x[i] - alpha / (sqrt(nhat) + eps) * mhat
  # evaluate candidate point
  score = objective(x[0], x[1])
  # store solution
  solutions.append(x.copy())
  # report progress
  print('>%d f(%s) = %.5f' % (t, x, score))
 return solutions

然后,我们可以像以前一样执行搜索,这一次将检索解决方案列表,而不是最佳的最终解决方案。

# seed the pseudo random number generator
seed(1)
# define range for input
bounds = asarray([[-1.0, 1.0], [-1.0, 1.0]])
# define the total iterations
n_iter = 50
# steps size
alpha = 0.02
# factor for average gradient
mu = 0.8
# factor for average squared gradient
nu = 0.999
# perform the gradient descent search with nadam
solutions = nadam(objective, derivative, bounds, n_iter, alpha, mu, nu)

然后,我们可以像以前一样创建目标函数的轮廓图。

# sample input range uniformly at 0.1 increments
xaxis = arange(bounds[0,0], bounds[0,1], 0.1)
yaxis = arange(bounds[1,0], bounds[1,1], 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a filled contour plot with 50 levels and jet color scheme
pyplot.contourf(x, y, results, levels=50, cmap='jet')

最后,我们可以将在搜索过程中找到的每个解决方案绘制成一条由一条线连接的白点。

# plot the sample as black circles
solutions = asarray(solutions)
pyplot.plot(solutions[:, 0], solutions[:, 1], '.-', color='w')

综上所述,下面列出了对测试问题执行Nadam优化并将结果绘制在轮廓图上的完整示例。

# example of plotting the nadam search on a contour plot of the test function
from math import sqrt
from numpy import asarray
from numpy import arange
from numpy import product
from numpy.random import rand
from numpy.random import seed
from numpy import meshgrid
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
 
# objective function
def objective(x, y):
 return x**2.0 + y**2.0
 
# derivative of objective function
def derivative(x, y):
 return asarray([x * 2.0, y * 2.0])
 
# gradient descent algorithm with nadam
def nadam(objective, derivative, bounds, n_iter, alpha, mu, nu, eps=1e-8):
 solutions = list()
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] - bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize decaying moving averages
 m = [0.0 for _ in range(bounds.shape[0])]
 n = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent
 for t in range(n_iter):
  # calculate gradient g(t)
  g = derivative(x[0], x[1])
  # build a solution one variable at a time
  for i in range(bounds.shape[0]):
   # m(t) = mu * m(t-1) + (1 - mu) * g(t)
   m[i] = mu * m[i] + (1.0 - mu) * g[i]
   # n(t) = nu * n(t-1) + (1 - nu) * g(t)^2
   n[i] = nu * n[i] + (1.0 - nu) * g[i]**2
   # mhat = (mu * m(t) / (1 - mu)) + ((1 - mu) * g(t) / (1 - mu))
   mhat = (mu * m[i] / (1.0 - mu)) + ((1 - mu) * g[i] / (1.0 - mu))
   # nhat = nu * n(t) / (1 - nu)
   nhat = nu * n[i] / (1.0 - nu)
   # x(t) = x(t-1) - alpha / (sqrt(nhat) + eps) * mhat
   x[i] = x[i] - alpha / (sqrt(nhat) + eps) * mhat
  # evaluate candidate point
  score = objective(x[0], x[1])
  # store solution
  solutions.append(x.copy())
  # report progress
  print('>%d f(%s) = %.5f' % (t, x, score))
 return solutions
 
# seed the pseudo random number generator
seed(1)
# define range for input
bounds = asarray([[-1.0, 1.0], [-1.0, 1.0]])
# define the total iterations
n_iter = 50
# steps size
alpha = 0.02
# factor for average gradient
mu = 0.8
# factor for average squared gradient
nu = 0.999
# perform the gradient descent search with nadam
solutions = nadam(objective, derivative, bounds, n_iter, alpha, mu, nu)
# sample input range uniformly at 0.1 increments
xaxis = arange(bounds[0,0], bounds[0,1], 0.1)
yaxis = arange(bounds[1,0], bounds[1,1], 0.1)
# create a mesh from the axis
x, y = meshgrid(xaxis, yaxis)
# compute targets
results = objective(x, y)
# create a filled contour plot with 50 levels and jet color scheme
pyplot.contourf(x, y, results, levels=50, cmap='jet')
# plot the sample as black circles
solutions = asarray(solutions)
pyplot.plot(solutions[:, 0], solutions[:, 1], '.-', color='w')
# show the plot
pyplot.show()

运行示例将像以前一样执行搜索,但是在这种情况下,将创建目标函数的轮廓图。

在这种情况下,我们可以看到在搜索过程中找到的每个解决方案都显示一个白点,从最优点开始,逐渐靠近图中心的最优点。

作者:沂水寒城,优快云博客专家,个人研究方向:机器学习、深度学习、NLP、CV

Blog: http://yishuihancheng.blog.youkuaiyun.com


觉得还不错就给我一个小小的鼓励吧!


梯度下降优化器:SGD -> SGDM -> NAG ->AdaGrad -> AdaDelta -> Adam -> Nadam -> AdamW 梯度下降优化器:SGD -> SGDM -> NAG ->AdaGrad -> AdaDelta -> Adam -> Nadam -> AdamW 阅读详情

相关推荐

梯度下降(二):自适应梯度(AdaGrad)、均方根传递(RMSProp)、自适应增量(AdaDelta)、自适应矩估计(Adam)、Nesterov自适应矩估计(Nadam)

梯度下降(二):自适应学习率(AdaGrad)、均方根传递(RMSProp)、自适应增量(AdaDelta)、自适应性矩估计(Adam)Nesterov自适应性矩估计(Nadam)前言自适应梯度(AdaGrad / Adaptive Gradient)均方根传递(RMSProp / Root Mean Square Propagation)自适应增量(AdaDelta)自适应矩估计(Adam /...

weixin_43290523的博客 1万+

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

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

网络资源是无限的 6750

PyTorch自定义优化器实战:从零实现Lion并兼容DDP/AMP/compile

优化器是深度学习训练的核心组件,其本质是参数更新规则与状态管理的统一体。理解torch.optim.Optimizer基类的设计原理,有助于掌握梯度更新、动量维护、设备同步和序列化等底层机制。本文以Lion优化器为范例,详解如何继承Optimizer构建生产级自定义优化器,覆盖参数组管理、state_dict容错加载、sign-based梯度更新、foreach批量加速等关键技术点,并确保与混合精度(AMP)、分布式训练(DDP)、图编译(torch.compile)及学习率调度器完全兼容。适用于算法创新、

weixin_30613727的博客 677

从零开始使用Nadam进行梯度下降优化

【翻译自 : Gradient Descent Optimization With Nadam From Scratch】 【说明:Jason BrownleePhD大神的文章个人很喜欢,所以闲暇时间里会做一点翻译和学习实践的工作,这里是相应工作的实践记录,希望能帮到有需要的人!】 梯度下降是一种优化算法,遵循目标函数的负梯度以定位函数的最小值。 梯度下降的局限性在于,如果梯度变为平坦或大曲率,搜索的进度可能会减慢。可以将动量添...

Together_CZ的博客 2999

神经网络隐藏层与节点数设计:从理论到实践的平衡艺术

神经网络的设计核心在于模型容量与泛化能力的权衡。模型容量决定了网络拟合复杂函数的能力,而泛化能力则关乎模型对新数据的预测效果。在工程实践中,这一平衡直接影响训练效率和最终性能。通过理解偏差-方差权衡,开发者可以避免欠拟合与过拟合的常见陷阱。本文聚焦于隐藏层与节点数的确定,这一过程没有固定公式,而是依赖于数据集大小、任务复杂度及硬件约束。文章将探讨如何从建立基线模型出发,逐步增加网络宽度与深度,并运用Dropout等正则化技术优化模型。最终,这些方法能帮助开发者在资源受限条件下,为分类、回归等任务设计出高效的

weixin_34007886的博客 327

光栅衍射有入射角时_衍射型多焦点人工晶体光学原理

多焦点人工晶体如何把光线分成多个焦点的?这个问题大部分专业书只是蜻蜓点水,并没有讲明白。希此文粗浅的解释,能帮您加深理解,请多指正。接下来,我将按照一下历史发展的顺序讲解一下:光的认识、菲涅尔灯塔(菲涅尔透镜)、菲涅尔波带盘(半波带盘)、多焦点人工晶体。一:首先复习一下光的认识历史。我们现在都知道光是一种电磁波,具有波粒二相性,但是认识光的本质也经历非常曲折漫长的过程。牛顿时代的几何光...

weixin_28963467的博客 2353

Machine Learning Mastery 优化教程(三)

原文:Machine Learning Mastery 协议:CC BY-NC-SA 4.0 使用 SciPy 的函数优化 原文:https://machinelearningmastery.com/function-optimization-with-scipy/ 最后更新于 2021 年 10 月 12 日 优化包括找到目标函数的输入,从而得到函数的最小或最大输出。 用于科学计算的开源 Python 库 SciPy 提供了一套优化算法。许多算法被用作其他算法的构件,最著名的是 Sklearn 库

龙哥盟 1369

N5105 PVE UEFI核显直通Windows:从黑屏到HDMI输出的实战调优

本文详细介绍了在N5105处理器上实现PVE UEFI核显直通Windows的实战调优方法。针对黑屏和HDMI音频无法识别等常见问题,提供了系统参数调整、驱动模块加载、虚拟机配置等解决方案,帮助用户成功实现核显直通并优化性能。

weixin_42566424的博客 207

cuda从零开始手搓PB神经网络

基于上一篇的矩阵点乘,实现了矩阵的加减乘除、函数调用等。并且复用之前元编程里面写的梯度下降、Adam、NAdam优化方法。可以看出,经过8000次的训练,这个使用sigmoid激活函数、NAdam优化、Xavier-Gaussian初始化的32。虽然这对于我的工作没有任何关系,但是我还是想搞一下。毕竟“越是没用的知识就越有用,越是有用的东西就越没用”。32的PB能够将误差缩减到0.0001这个量级,而训练时间仅为8.54秒。下面实验一下我们的bp神经网络。

Dr_Jack的博客 645

STK相关总结

STK简介 一.SIM卡应用工具包(SIM Application Toolkit),又名CAT/USAT,它包含一系列终端与SIM卡的交互指令,SIM卡可以应用卡内的小应用程序和终端交互,从而实现增值服务的目的,STK包括三种类,STK-imsi切换,STK –OTA,STK-BIP 功能: (1) Profile download:配置下载,开机初始化SIM卡过程中,终端告诉SIM卡终端支持哪些功能,STK中download指终端将数据发送给SIM卡 (2) Proactive command: 主动式

jingjing_2的博客 3360

android mtk camera如何自定义默认拍照与录像分辨率

本文详细解析了在Android MTK平台上自定义相机默认拍照与录像分辨率的方法。通过分析Camera2应用默认选择逻辑,定位并修改PictureSize.java与VideoQualityCaptureRequestConfig.java中的关键代码,实现绕过系统智能选择,强制指定最高或特定分辨率。文章还提供了进阶的可配置化方案与验证避坑指南,帮助开发者精准控制相机行为。

weixin_29194817的博客 436

深度学习实战:MNIST数据集上不同优化算法的比较分析

在深度学习模型训练过程中,优化算法的选择对模型性能有着至关重要的影响。本文基于深度学习从零开始项目中的优化器比较实验,详细解析了四种常见优化算法(SGD、Momentum、AdaGrad和Adam)在MNIST手写数字识别任务上的表现差异。 ## 实验设置 ### 数据集准备 实验使用经典的MNIST手写数字数据集,该数据集包含60,000张训练图像和10,000张测试图像,每张图像为28x...

gitblog_00591的博客 493

vue中使用video-player视频插件,第一次无法监听父组件穿过来的值解决办法

需求: 页面![在这里插入图片描述](https://img-blog.csdnimg.cn/20201208141906802.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfOTg4OA==,size_16,color_FFFFFF,t_70) 作品清单是从后端请求回来的不同格式的url,前端需求根据后缀动态判断格式,然后对齐进行下载和

A_9888的博客 772

从入门python到搭建神经网络

为了加深对机器学习的理解,我通过Tensorflow和Keras搭建了一些简单的神经网络模型。在这个过程中,对获取数据、数据预处理、模型训练、模型评估环节也有了更完整的理解。 一、学习路径 学习机器学习—>入门Python—> 入门tensorflow、keras搭建模型 1.在开始搭建模型之前,我已经二刷了李宏毅的机器学习视频,做学习笔记整理的时候又挑重点的进行了三刷。并阅读了相关书...

plusli的博客 2934

华为OD机试真题2025双机位A卷 Python&JavaScript 实现【采购订单】

在一个采购系统中,采购申请(PR)需要经过审批后才能生成采购订单(PO)。每个PR包含商品的单价(假设相同商品的单价一定是一样的)及数量信息。系统要求对商品进行分类处理:单价高于100元的商品需要单独处理,单价低于或等于100元的相同商品可以合并到同一采购订单PO中。针对单价低于100的小额订单,如果量大可以打折购买。

MISAYAONE的博客 1464

信号的反射(振铃、台阶、回勾、尖峰毛刺)

反射是怎么形成的 假设信号传输过程中,经过两个阻抗不同的区域,如下图所示。区域1阻抗为Z1,区域2阻抗为Z2。 在分界面处,电压必须是连续的,否则,在分界面处会产生无穷大的电场,这在真实世界中是不可能的。 同样,分界面两侧的电流必须是连续的,否则分界面处会产生无穷大的磁场。 因此: 根据欧姆定律,必然有: 显然如果Z1≠Z2的情况下,上面式子不可能同时成立。如何理解这一困境? 应该从 ...

sinat_15677011的博客 1万+

adadelta算法_对C++用户比较友好的机器学习算法库

由于疫情影响,这几天在家学习编程,整理了基于c++语言的机器学习算法库。目前大部分机器学习库都是面向pyhton语言的,尽管很python包的底层语言是c++,但c++用户使用起来很麻烦,这里整理了一些对c++比较优化的机器学习算法库,包括:Dlib,DLL,L2,MLpack,ensmallen,opennn,opencv等。下面对这些库进行简单介绍:(1)Dlib——C++机器学习库...

weixin_29615645的博客 504

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

深度学习优化算法全解析:从SGD到AdamW的演进与实战选择

在机器学习与深度学习领域,优化算法是模型训练的核心引擎,其目标是在高维参数空间中高效寻找损失函数的最小值。其基本原理是沿着梯度反方向迭代更新参数,以最小化预测误差。自适应学习率技术通过为不同参数动态调整更新步长,显著提升了训练效率与稳定性,具有重要的技术价值。这类算法广泛应用于计算机视觉、自然语言处理等场景的模型训练中。本文聚焦于**AdamW**这一当前主流优化器,它通过解耦权重衰减解决了传统Adam中的耦合问题,同时结合了动量与自适应学习率的优势。对于追求极致性能的任务,精调过的**SGD with M

weixin_30751947的博客 370

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

深度学习调优小技巧

转:https://blog.youkuaiyun.com/xinyuski/article/details/84400527 1:优化器。机器学习训练的目的在于更新参数,优化目标函数,常见优化器有SGD,Adagrad,Adadelta,Adam,Adamax,Nadam。其中SGD和Adam优化器是最为常用的两种优化器,SGD根据每个batch的数据计算一次局部的估计,最小化代价函数。 学习速率决定了...

Jaykie 1144

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

深度学习技巧总结

一、深度学习算法调优技巧 1:优化器。机器学习训练的目的在于更新参数,优化目标函数,常见优化器有SGD,Adagrad,Adadelta,Adam,Adamax,Nadam。其中SGD和Adam优化器是最为常用的两种优化器,SGD根据每个batch的数据计算一次局部的估计,最小化代价函数。 学习速率决定了每次步进的大小,因此我们需要选择一个合适的学习速率进行调优。学习速率太大会导致不收敛,速率...

一米阳光-的博客 2717

深度学习基础模型算法原理及编程实现--11.构建简化版的tensorflow---MiniFlow【实现MLP对MNIST数据分类】

文章列表 1.深度学习基础模型算法原理及编程实现–01.感知机. 2.深度学习基础模型算法原理及编程实现–02.线性单元 . 3.深度学习基础模型算法原理及编程实现–03.全链接 . 4.深度学习基础模型算法原理及编程实现–04.改进神经网络的方法 . 5.深度学习基础模型算法原理及编程实现–05.卷积神经网络. 6.深度学习基础模型算法原理及编程实现–06.循环神经网络. 9.深度...

drilistbox的博客 1409

深度学习优化算法大全系列7:NAdam,算法选择,调参

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

bitcarmanlee的博客 5599

深度学习模型组件之优化器--Nadam结合 Adam 与 Nesterov 加速(Nadam)

近年来,深度学习模型的训练离不开高效的优化算法。从最基础的随机梯度下降(SGD)到 Momentum、AdaGrad、RMSProp,再到 Adam,优化算法不断演进以适应大规模、高维非凸问题的挑战。Nadam(Nesterov-accelerated Adaptive Moment Estimation) 正是在这一发展过程中出现的,它在 Adam 的基础上引入了 Nesterov 加速技术,从而融合了自适应学习率和预见性动量的优点。

404 Not Found 2020

机器学习优化过程中的各种梯度下降方法((SGD, Momentum,Nesterov,Adagrad,RMSprop,Adadelta,Adam,Adamax,Nadam)

除了调整学习率之外,还可以通过使用最近一段时间内的平均梯度来代替当前时刻的梯度来作为参数更新的方向。在小批量梯度下降中,如果每次选取样本数量比较小,损失会呈现震荡的方式下降。有效地缓解梯度下降中的震荡的方式是通过用梯度的移动平均来代替每次的实际梯度,并提高优化速度,这就是动量法。动量是模拟物理中的概念。一般而言,一个物体的动量指的是这个物体在它运动方向上保持运动的趋势,是物体的质量和速度的乘积。动量法(MomentumMethod)[Rumelhart et al., 1988]是用之前积累动量来替代真正的

2018
上一篇: 实操教程|如何使用Transformer来做物体检测?DETR模型完整指南
下一篇: 那些年的Coding5分钟,部署2小时?漫画解释一下部署
Wang_AI
博客等级 码龄12年 998粉丝 162原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值