Nadam을 사용한 경사하강법 최적화

21 12월

Nadam을 사용한 경사하강법 최적화

경사하강법은 함수의 최소값을 찾기 위해 목적 함수의 음의 기울기를 따르는 최적화 알고리즘입니다.

경사하강법의 한계는 경사가 평평하거나 큰 곡률이 될 경우 검색 진행이 느려질 수 있다는 것입니다. 업데이트에 약간의 관성을 통합하는 경사 하강에 모멘텀을 추가할 수 있습니다. 이것은 Nesterov의 가속 기울기 (NAG) 또는 Nesterov 운동량이라고하는 현재 위치가 아닌 예상된 새 위치의 기울기를 통합하여 더욱 향상시킬 수 있습니다.

경사하강법의 또 다른 한계는 모든 입력 변수에 대해 단일 스텝 크기(학습률)가 사용된다는 것입니다. 각 입력 변수에 대해 별도의 스텝 크기를 사용하지만 스텝 크기가 매우 작은 값으로 빠르게 감소할 수 있는 적응형 이동 추정(Adam) 알고리즘과 같은 경사하강법으로의 확장.

Nesterov 가속 적응 모멘트 추정 또는 Nadam은 Nesterov 운동량을 통합하고 최적화 알고리즘의 성능을 향상시킬 수 있는 Adam 알고리즘의 확장입니다.

이 튜토리얼에서는 Nadam을 사용하여 경사하강법 최적화를 처음부터 개발하는 방법을 알아봅니다.

이 자습서를 완료하면 다음을 알 수 있습니다.

경사하강법은 목적 함수의 기울기를 사용하여 검색 공간을 탐색하는 최적화 알고리즘입니다.
Nadam은 Nesterov 운동량을 통합하는 경사 하강법의 Adam 버전의 확장입니다.
Nadam 최적화 알고리즘을 처음부터 구현하여 목적 함수에 적용하고 결과를 평가하는 방법.

튜토리얼 개요

이 자습서는 다음과 같이 세 부분으로 나뉩니다.

경사하강법
나담 최적화 알고리즘
나담과의 경사 하강
1. 2차원 테스트 문제
2. Nadam을 사용한 경사하강법 최적화
3. 나담 최적화의 시각화

경사하강법

경사하강법은 최적화 알고리즘입니다.

기술적으로 1차 최적화 알고리즘이라고 하며, 목표 목적 함수의 1차 도함수를 명시적으로 사용합니다.

1 차 방법은 그래디언트 정보에 의존하여 검색을 최소값으로 안내합니다 …

— 69페이지, 최적화 알고리즘, 2019.

1차 도함수 또는 간단히 “도함수”는 예를 들어 특정 입력에 대한 특정 지점에서 목표 함수의 변화율 또는 기울기입니다.

대상 함수가 여러 입력 변수를 취하는 경우 이를 다변량 함수라고 하며 입력 변수를 벡터로 생각할 수 있습니다. 차례로, 다변량 목표 함수의 도함수는 또한 벡터로 취해질 수 있으며 일반적으로 그래디언트라고 합니다.

기울기: 다변량 목적 함수에 대한 1차 도함수입니다.

미분 또는 기울기는 특정 입력값에 대한 목표 함수의 가장 가파른 상승 방향을 가리킵니다.

경사하강법은 함수의 최소값을 찾기 위해 대상 함수의 기울기 내리막의 음수를 따르는 최소화 최적화 알고리즘을 말합니다.

경사하강법 알고리즘에는 최적화되는 목표 함수와 목적 함수에 대한 미분 함수가 필요합니다. 목표 함수 f()는 주어진 입력 세트에 대한 점수를 반환하고, 미분 함수 f'()는 주어진 입력 세트에 대한 타겟 함수의 도함수를 제공합니다.

경사하강법 알고리즘에는 입력 공간에서 임의로 선택된 점과 같이 문제의 시작점(x)이 필요합니다.

그런 다음 미분이 계산되고 목표 함수를 최소화한다고 가정할 때 목표 함수에서 내리막 이동이 발생할 것으로 예상되는 입력 공간에서 한 걸음을 수행합니다.

내리막 이동은 먼저 입력 공간에서 이동할 거리를 계산하여 이루어지며, 단계 크기(알파 또는 학습률이라고 함)에 기울기를 곱하여 계산됩니다. 그런 다음 현재 지점에서 빼서 그라디언트에 대해 이동하거나 대상 함수 아래로 이동합니다.

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

주어진 점에서 목적 함수가 가파를수록 기울기의 크기가 커지고 검색 공간에서 취해지는 단계가 커집니다. 수행된 단계의 크기는 단계 크기 하이퍼파라미터를 사용하여 조정됩니다.

Step Size: 알고리즘의 각 반복에서 기울기에 대해 검색 공간에서 이동할 거리를 제어하는 하이퍼파라미터입니다.

단계 크기가 너무 작 으면 검색 공간에서의 움직임이 작아지고 검색 시간이 오래 걸립니다. 단계 크기가 너무 크면 검색이 검색 공간을 돌아다니며 최적 단계를 건너뛸 수 있습니다.

이제 경사하강법 최적화 알고리즘에 익숙해졌으므로 Nadam 알고리즘을 살펴보겠습니다.

나담 최적화 알고리즘

Nesterov-가속 적응 모멘트 추정 또는 Nadam 알고리즘은 향상된 유형의 운동량인 Nesterov의 가속 기울기(NAG) 또는 Nesterov 운동량을 추가하기 위해 적응형 운동 추정(Adam) 최적화 알고리즘의 확장입니다.

보다 광범위하게 Nadam 알고리즘은 경사하강법 최적화 알고리즘의 확장입니다.

이 알고리즘은 Timothy Dozat의 2016 년 논문 “Nesterov Momentum into Adam”에 설명되어 있습니다. 이 논문의 버전은 2015 년에 같은 이름의 스탠포드 프로젝트 보고서로 작성되었지만.

모멘텀은 기울기의 기하급수적으로 감소하는 이동 평균(첫 번째 모멘트)을 경사하강법 알고리즘에 추가합니다. 이는 잡음이 있는 목적 함수를 매끄럽게 하고 수렴을 개선하는 효과가 있습니다.

Adam은 경사의 첫 번째와 두 번째 모멘트를 추가하고 최적화되는 각 파라미터에 대해 학습률을 자동으로 조정하는 경사하강법의 확장입니다. NAG는 실제 현재 변수 값이 아닌 매개변수에 대한 투영된 업데이트의 기울기를 사용하여 업데이트가 수행되는 모멘텀의 확장입니다. 이는 일부 상황에서 오버슈팅보다는 최적이 위치할 때 검색 속도를 늦추는 효과가 있습니다.

Nadam은 고전적인 운동량 대신 NAG 운동량을 사용하는 Adam의 확장입니다.

NAG의 통찰력을 활용하기 위해 Adam의 운동량 성분을 수정하는 방법을 보여준 다음, 이 대체를 수행하면 수렴 속도와 학습된 모델의 품질이 향상된다는 예비 증거를 제시합니다.

— 네스테로프 모멘텀을 아담에 통합, 2016.

알고리즘의 각 요소를 단계별로 살펴보겠습니다.

Nadam은 성능을 향상시킬 수 있는 감소 단계 크기(알파) 및 첫 번째 모멘트(mu) 하이퍼파라미터를 사용합니다. 단순성의 경우 지금은 이 측면을 무시하고 상수 값을 가정합니다.

먼저, 검색의 일부로 최적화되는 각 매개 변수에 대한 기울기의 첫 번째 및 두 번째 순간 (각각 m 및 n이라고함)을 유지해야합니다. 검색 시작 시 0.0으로 초기화됩니다.

m = 0
n = 0

알고리즘은 t=1에서 시작하는 시간 t에 걸쳐 반복적으로 실행되며, 각 반복에는 x(t-1)에서 x(t)로 이동하는 것과 같이 새로운 매개변수 값 x 집합을 계산하는 작업이 포함됩니다.

벡터 연산을 통해 모든 매개 변수를 업데이트하는 것으로 일반화되는 하나의 매개 변수를 업데이트하는 데 집중하면 알고리즘을 이해하기 쉽습니다.

먼저, 현재 시간 스텝에 대한 기울기(부분 도함수)가 계산됩니다.

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 운동량을 사용하여 바이어스 보정됩니다.

마트 = (뮤 * m (t) / (1 – 뮤)) + ((1 – 뮤) * g (t) / (1 – 뮤))

그런 다음 두 번째 순간이 편향 수정됩니다.

참고 : 바이어스 수정은 Adam의 한 측면이며 검색 시작시 첫 번째와 두 번째 순간이 0으로 초기화된다는 사실을 반박합니다.

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

마지막으로 이 반복에 대한 매개 변수 값을 계산할 수 있습니다.

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

여기서 alpha는 스텝 크기(학습률) 하이퍼파라미터이고, sqrt()는 제곱근 함수이며, eps(epsilon)는 0으로 나누기 오류를 피하기 위해 추가된 1e-8과 같은 작은 값입니다.

검토하기 위해 알고리즘에 대한 세 가지 하이퍼 매개 변수가 있습니다. 그들은:

alpha: 초기 스텝 크기(학습률)로, 일반적인 값은 0.002입니다.
mu: 첫 번째 순간의 붕괴 계수(Adam의 경우 beta1), 일반적인 값은 0.975입니다.
nu: 두 번째 모멘트(Adam의 beta2)에 대한 감쇠 계수, 일반적인 값은 0.999입니다.

그리고 그게 다야.

다음으로 Python에서 알고리즘을 처음부터 구현하는 방법을 살펴보겠습니다.

나담과의 경사 하강

이 섹션에서는 Nadam Momentum을 사용하여 경사하강법 최적화 알고리즘을 구현하는 방법을 살펴보겠습니다.

<>차원 테스트 문제

먼저 최적화 함수를 정의해 보겠습니다.

각 차원의 입력을 제곱하고 -1.0에서 1.0까지의 유효한 입력 범위를 정의하는 간단한 2 차원 함수를 사용합니다.

아래의 objective()함수는이 함수를 구현합니다.

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

반응 표면의 곡률에 대한 느낌을 얻기 위해 데이터 세트의 3차원 플롯을 만들 수 있습니다.

목적 함수를 플로팅하는 전체 예제는 다음과 같습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 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()

예제를 실행하면 목적 함수의 3차원 표면도가 생성됩니다.

f(0, 0) = 0에서 전역 최소값으로 친숙한 그릇 모양을 볼 수 있습니다.

검정 목적 함수의 <>차원 플롯

함수의 2차원 플롯을 만들 수도 있습니다. 이것은 나중에 검색 진행률을 플롯하려는 경우에 유용합니다.

아래 예제에서는 목적 함수의 등고선도를 생성합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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()

예제를 실행하면 목적 함수의 2차원 등고선도가 생성됩니다.

색상 그라데이션으로 표시된 윤곽선으로 압축된 그릇 모양을 볼 수 있습니다. 이 플롯을 사용하여 검색을 진행하는 동안 탐색된 특정 지점을 플로팅합니다.

검정 목적 함수의 2차원 등고선도

이제 테스트 목적 함수가 있으므로 Nadam 최적화 알고리즘을 구현하는 방법을 살펴보겠습니다.

Nadam을 사용한 경사하강법 최적화

Nadam을 사용한 경사하강법을 테스트 문제에 적용할 수 있습니다.

먼저이 함수의 도함수를 계산하는 함수가 필요합니다.

x^2의 도함수는 각 차원에서 x * 2입니다.

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

derivative() 함수는 아래에서 이를 구현합니다.

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

다음으로 Nadam으로 경사하강법 최적화를 구현할 수 있습니다.

먼저 문제 경계의 임의의 점을 검색의 시작점으로 선택할 수 있습니다.

여기서는 각 차원에 대해 하나의 행으로 검색 범위를 정의하는 배열이 있고 첫 번째 열은 최소값을 정의하고 두 번째 열은 차원의 최대값을 정의한다고 가정합니다.

1
2
3
4
...
# generate an initial point
x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] – bounds[:, 0])
score = objective(x[0], x[1])

다음으로 모멘트 벡터를 초기화해야 합니다.

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

그런 다음 “n_iter” 하이퍼파라미터로 정의된 알고리즘의 고정된 반복 횟수를 실행합니다.

1
2
3
4
...
# run iterations of gradient descent
for t in range(n_iter):
 ...

첫 번째 단계는 현재 매개 변수 집합에 대한 도함수를 계산하는 것입니다.

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

다음으로 Nadam 업데이트 계산을 수행해야 합니다. 가독성을 위해 명령형 프로그래밍 스타일을 사용하여 한 번에 하나의 변수로 이러한 계산을 수행합니다.

실제로 효율성을 위해 NumPy 벡터 연산을 사용하는 것이 좋습니다.

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

먼저 모멘트 벡터를 계산해야 합니다.

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

그런 다음 두 번째 모멘트 벡터.

1
2
3
...
# n(t) = nu * n(t-1) + (1 – nu) * g(t)^2
n[i] = nu * n[i] + (1.0 – nu) * g[i]**2

그런 다음 바이어스 수정 된 네스테로프 모멘텀.

1
2
3
...
# 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))

바이어스가 올바른 두 번째 순간.

1
2
3
...
# nhat = nu * n(t) / (1 – nu)
nhat = nu * n[i] / (1.0 – nu)

마지막으로 매개 변수를 업데이트합니다.

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

그런 다음 최적화되는 각 매개 변수에 대해 이 작업이 반복됩니다.

반복이 끝나면 새 매개 변수 값을 평가하고 검색 성능을 보고할 수 있습니다.

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

이 모든 것을 목적 함수와 미분 함수의 이름과 알고리즘 하이퍼 매개 변수를 취하는 nadam() 이라는 함수로 묶을 수 있으며 검색 및 평가가 끝날 때 찾은 최상의 솔루션을 반환합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 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]

그런 다음 함수와 하이퍼파라미터의 경계를 정의하고 함수를 호출하여 최적화를 수행할 수 있습니다.

이 경우 약간의 시행 착오 끝에 발견 된 초기 알파 0.02, mu 0.8, nu 0.999로 50 회 반복 알고리즘을 실행합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
# 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)

실행이 끝나면 찾은 최상의 솔루션을보고합니다.

1
2
3
4
...
# summarize the result
print(‘Done!’)
print(‘f(%s) = %f’ % (best, score))

이 모든 것을 하나로 묶어 테스트 문제에 적용된 Nadam 경사하강법의 전체 예가 아래에 나열되어 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# 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을 사용한 최적화 알고리즘이 테스트 문제에 적용되고 알고리즘의 각 반복에 대한 검색 성능이 보고됩니다.

참고: 결과는 알고리즘 또는 평가 절차의 확률적 특성 또는 수치 정밀도의 차이에 따라 달라질 수 있습니다. 예제를 몇 번 실행하고 평균 결과를 비교하는 것이 좋습니다.

이 경우 입력 값이 0.0과 0.0에 가깝고 0.0으로 평가되는 검색을 44회 반복한 후 최적에 가까운 솔루션이 발견되었음을 알 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
…
>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() 함수를 업데이트하여 검색 중에 찾은 모든 솔루션 목록을 유지 관리한 다음 검색이 끝날 때 이 목록을 반환해야 합니다.

이러한 변경 사항이 적용된 함수의 업데이트된 버전은 다음과 같습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 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

그런 다음 이전과 같이 검색을 실행하고 이번에는 최상의 최종 솔루션 대신 솔루션 목록을 검색 할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
# 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)

그런 다음 이전과 같이 목적 함수의 등고선도를 만들 수 있습니다.

1
2
3
4
5
6
7
8
9
10
...
# 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’)

마지막으로 검색 중에 찾은 각 솔루션을 선으로 연결된 흰색 점으로 그릴 수 있습니다.

1
2
3
4
...
# plot the sample as black circles
solutions = asarray(solutions)
pyplot.plot(solutions[:, 0], solutions[:, 1], ‘.-‘, color=‘w’)

이 모든 것을 하나로 묶어 테스트 문제에 대해 Nadam 최적화를 수행하고 등고선도에 결과를 플로팅하는 전체 예가 아래에 나열되어 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# 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()

예제를 실행하면 이전과 같이 검색이 수행되지만 이 경우 목적 함수의 등고선도가 생성됩니다.

이 경우 검색 중에 발견 된 각 솔루션에 대해 최적 값 위에서 시작하여 플롯 중심의 최적값에 점차 가까워지는 흰색 점이 표시되는 것을 볼 수 있습니다.

Nadam 검색 결과가 표시된 검정 목적 함수의 등고선도

추가 정보

이 섹션에서는 더 자세히 알아보려는 경우 주제에 대한 더 많은 리소스를 제공합니다.

논문

책

최적화를위한 알고리즘, 2019.
딥러닝, 2016.

증권 시세 표시기

기사

요약

이 자습서에서는 Nadam을 사용하여 경사하강법 최적화를 처음부터 개발하는 방법을 알아보았습니다.

특히 다음 내용을 배웠습니다.

경사하강법은 목적 함수의 기울기를 사용하여 검색 공간을 탐색하는 최적화 알고리즘입니다.
Nadam은 Nesterov 운동량을 통합하는 경사 하강법의 Adam 버전의 확장입니다.
Nadam 최적화 알고리즘을 처음부터 구현하여 목적 함수에 적용하고 결과를 평가하는 방법.

Tags:

Gradient Descent Optimization,Machine learning

Nadam을 사용한 경사하강법 최적화

튜토리얼 개요

경사하강법

나담 최적화 알고리즘

나담과의 경사 하강

<>차원 테스트 문제

Nadam을 사용한 경사하강법 최적화

나담 최적화의 시각화

추가 정보

논문

책

증권 시세 표시기

기사

요약

Tags:

네피리티

No Comments

Latest Posts

Latest Tweets

Latest Posts