적응형 이동 추정 알고리즘 (Adaptive Movement Estimation algorithm) 코딩하기

21 12월

적응형 이동 추정 알고리즘 (Adaptive Movement Estimation algorithm) 코딩하기

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

경사하강법의 한계는 모든 입력 변수에 대해 단일 단계 크기(학습률)가 사용된다는 것입니다. AdaGrad 및 RMSProp과 같은 경사하강법 확장은 각 입력 변수에 대해 별도의 스텝 크기를 사용하도록 알고리즘을 업데이트하지만 스텝 크기가 매우 작은 값으로 빠르게 줄어들 수 있습니다.

적응형 이동 추정 알고리즘 (Adaptive Movement Estimation algorithm) 또는 줄여서 Adam은 경사하강법의 확장이며 목적 함수의 각 입력 변수에 대한 학습률을 자동으로 조정하고 기울기의 기하급수적으로 감소하는 이동 평균을 사용하여 변수를 업데이트함으로써 검색 프로세스를 더욱 원활하게 하는 AdaGrad 및 RMSProp과 같은 기술의 자연스러운 후속 기술입니다.

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

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

경사하강법은 목적 함수의 기울기를 사용하여 검색 공간을 탐색하는 최적화 알고리즘입니다.
경사하강법은 Adam이라는 편미분의 감쇠 평균을 사용하여 각 입력 변수에 대해 자동 적응형 스텝 크기를 사용하도록 업데이트할 수 있습니다.
Adam 최적화 알고리즘을 처음부터 구현하고 목적 함수에 적용하고 결과를 평가하는 방법.

튜토리얼 개요

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

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

경사하강법

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

아담 최적화 알고리즘

적응형 이동 추정 알고리즘 또는 줄여서 Adam은 경사하강법 최적화 알고리즘의 확장입니다.

이 알고리즘은 Diederik Kingma와 Jimmy Lei Ba의 2014 년 논문 “Adam: 확률 최적화를 위한 방법“에 설명되어 있습니다.

Adam은 최적화 프로세스를 가속화하도록 설계되었습니다(예: 최적에 도달하는 데 필요한 함수 평가 횟수 감소) 또는 최적화 알고리즘의 기능을 개선(예: 더 나은 최종 결과 결과).

이는 최적화되는 각 입력 매개 변수의 단계 크기를 계산하여 수행됩니다. 중요하게도, 각 스텝 크기는 각 변수에 대해 발생하는 기울기(편미분)를 기반으로 검색 프로세스의 처리량을 자동으로 조정한다.

우리는 메모리 요구 사항이 거의없는 1 차 기울기 만 필요로하는 효율적인 확률 적 최적화 방법 인 Adam을 제안합니다. 이 방법은 기울기의 첫 번째 및 두 번째 모멘트의 추정치로부터 서로 다른 매개 변수에 대한 개별 적응 학습률을 계산합니다. Adam이라는 이름은 적응 모멘트 추정에서 파생되었습니다.

— 아담: 확률적 최적화를 위한 방법

여기에는 기울기의 첫 번째 및 두 번째 모멘트(예: 각 입력 변수에 대한 기하급수적으로 감소하는 평균 기울기(첫 번째 모멘트) 및 분산(두 번째 모멘트)))을 유지하는 것이 포함됩니다.

이동 평균 자체는 기울기의 첫 번째 모멘트(평균)와 2번째 원시 모멘트(중심이 없는 분산)의 추정치입니다.

— 아담: 확률적 최적화를 위한 방법

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

먼저, 검색의 일부로 최적화되는 각 매개 변수에 대해 모멘트 벡터와 지수 가중 무한대 노름을 유지해야하며, 각각 m 및 v (실제로는 그리스 문자 nu)라고합니다. 검색 시작 시 0.0으로 초기화됩니다.

m = 0
v = 0

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

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

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

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

다음으로 첫 번째 모멘트는 그라디언트와 하이퍼파라미터 beta1을 사용하여 업데이트됩니다.

m (t) = 베타 1 * m (t-1) + (1 – 베타 1) * g (t)

그런 다음 두 번째 모멘트는 제곱 그라디언트와 하이퍼파라미터 beta2를 사용하여 업데이트됩니다.

v(t) = beta2 * v(t-1) + (1 – beta2) * g(t)^2

첫 번째와 두 번째 모멘트는 0 값으로 초기화되기 때문에 편향됩니다.

… 이러한 이동 평균은 (벡터) 0으로 초기화되어 특히 초기 시간 스텝 동안, 특히 감쇠율이 작은 경우(즉, 베타가 1에 가까울 때) 0에 편향된 모멘트 추정치로 이어집니다. 좋은 소식은 이 초기화 편향이 쉽게 대응되어 편향 수정 추정치를 초래할 수 있다는 것입니다.

— 아담: 확률적 최적화를 위한 방법

다음으로 첫 번째와 두 번째 순간은 편향 수정되어 첫 번째 순간과 함께 주연됩니다.

마트(t) = m(t) / (1 – 베타1(t))

그리고 두 번째 순간 :

VHAT(t) = v(t) / (1 – beta2(t))

beta1(t) 및 beta2(t)는 알고리즘 반복 동안 일정에 따라 감쇠되는 베타1 및 베타2 하이퍼파라미터를 나타냅니다. 정적 감쇠 일정을 사용할 수 있지만 백서에서는 다음을 권장합니다.

베타 1 (t) = 베타 1 ^ t
베타2(t) = 베타2^t

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

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

여기서 alpha는 스텝 크기 하이퍼파라미터이고, eps는 0으로 나누기 오류가 발생하지 않도록 하는 1e-8과 같은 작은 값(엡실론)이며, sqrt()는 제곱근 함수입니다.

문서에 나열된 업데이트 규칙의 보다 효율적인 재정렬을 사용할 수 있습니다.

알파 (t) = 알파 * sqrt (1 – 베타 2 (t)) / (1 – 베타 1 (t))
x (t) = x (t-1) – alpha (t) * m (t) / (sqrt (v (t)) + eps)

검토하기 위해 알고리즘에는 세 가지 하이퍼 매개 변수가 있습니다.

alpha: 초기 스텝 크기(학습률)로, 일반적인 값은 0.001입니다.
beta1: 첫 번째 운동량의 붕괴 계수, 일반적인 값은 0.9입니다.
beta2: 무한대 노름의 감쇠 계수로, 일반적인 값은 0.999입니다.

그리고 그게 다야.

Adam 알고리즘의 맥락에서 Adam 알고리즘을 완전히 도출하려면 백서를 읽는 것이 좋습니다.

아담: 확률적 최적화를 위한 방법

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

아담과 함께하는 경사하강

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

<>차원 테스트 문제

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

각 차원의 입력을 제곱하고 -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차원 등고선도

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

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

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

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

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

x^2의 도함수는 각 차원에서 x * 2입니다. derivative() 함수는 아래에서 이를 구현합니다.

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

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

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

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

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

다음으로 첫 번째와 두 번째 모멘트를 0으로 초기화해야 합니다.

1
2
3
4
...
# initialize first and second moments
m = [0.0 for _ in range(bounds.shape[0])]
v = [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):
 ...

첫 번째 단계는 derivative() 함수를 사용하여 현재 솔루션의 기울기를 계산하는 것입니다.

1
2
3
...
# calculate gradient
gradient = derivative(solution[0], solution[1])

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

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

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

실제로 효율성을 위해 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) = beta1 * m(t-1) + (1 – beta1) * g(t)
m[i] = beta1 * m[i] + (1.0 – beta1) * g[i]

그런 다음 두 번째 순간.

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

그런 다음 첫 번째와 두 번째 순간에 대한 바이어스 수정.

1
2
3
4
5
...
# mhat(t) = m(t) / (1 – beta1(t))
mhat = m[i] / (1.0 – beta1**(t+1))
# vhat(t) = v(t) / (1 – beta2(t))
vhat = v[i] / (1.0 – beta2**(t+1))

그런 다음 마지막으로 업데이트 된 변수 값입니다.

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

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

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

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

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

이 전체 기능은 다음과 같습니다.

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 adam
def adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2, eps=1e–8):
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] – bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize first and second moments
 m = [0.0 for _ in range(bounds.shape[0])]
 v = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent updates
 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(x.shape[0]):
 # m(t) = beta1 * m(t-1) + (1 – beta1) * g(t)
 m[i] = beta1 * m[i] + (1.0 – beta1) * g[i]
 # v(t) = beta2 * v(t-1) + (1 – beta2) * g(t)^2
 v[i] = beta2 * v[i] + (1.0 – beta2) * g[i]**2
 # mhat(t) = m(t) / (1 – beta1(t))
 mhat = m[i] / (1.0 – beta1**(t+1))
 # vhat(t) = v(t) / (1 – beta2(t))
 vhat = v[i] / (1.0 – beta2**(t+1))
 # x(t) = x(t-1) – alpha * mhat(t) / (sqrt(vhat(t)) + eps)
 x[i] = x[i] – alpha * mhat / (sqrt(vhat) + eps)
 # evaluate candidate point
 score = objective(x[0], x[1])
 # report progress
 print(‘>%d f(%s) = %.5f’ % (t, x, score))
 return [x, score]

참고 : 가독성을 위해 벡터화 된 작업 대신 의도적으로 목록과 명령형 코딩 스타일을 사용했습니다. 더 나은 성능을 위해 NumPy 배열을 사용하여 벡터화된 구현에 구현을 자유롭게 조정하십시오.

그런 다음 하이퍼파라미터를 정의하고 adam() 함수를 호출하여 테스트 목적 함수를 최적화할 수 있습니다.

이 경우 초기 단계 크기가 0.02이고 beta1 및 beta2 값이 각각 0.8 및 0.999인 알고리즘을 60회 반복합니다. 이러한 하이퍼파라미터 값은 약간의 시행착오 끝에 발견되었습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
# 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 = 60
# steps size
alpha = 0.02
# factor for average gradient
beta1 = 0.8
# factor for average squared gradient
beta2 = 0.999
# perform the gradient descent search with adam
best, score = adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2)
print(‘Done!’)
print(‘f(%s) = %f’ % (best, score))

이 모든 것을 하나로 묶어 Adam을 사용한 경사하강법 최적화의 전체 예가 아래에 나열되어 있습니다.

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 adam 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 adam
def adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2, eps=1e–8):
 # generate an initial point
 x = bounds[:, 0] + rand(len(bounds)) * (bounds[:, 1] – bounds[:, 0])
 score = objective(x[0], x[1])
 # initialize first and second moments
 m = [0.0 for _ in range(bounds.shape[0])]
 v = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent updates
 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(x.shape[0]):
 # m(t) = beta1 * m(t-1) + (1 – beta1) * g(t)
 m[i] = beta1 * m[i] + (1.0 – beta1) * g[i]
 # v(t) = beta2 * v(t-1) + (1 – beta2) * g(t)^2
 v[i] = beta2 * v[i] + (1.0 – beta2) * g[i]**2
 # mhat(t) = m(t) / (1 – beta1(t))
 mhat = m[i] / (1.0 – beta1**(t+1))
 # vhat(t) = v(t) / (1 – beta2(t))
 vhat = v[i] / (1.0 – beta2**(t+1))
 # x(t) = x(t-1) – alpha * mhat(t) / (sqrt(vhat(t)) + eps)
 x[i] = x[i] – alpha * mhat / (sqrt(vhat) + eps)
 # 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 = 60
# steps size
alpha = 0.02
# factor for average gradient
beta1 = 0.8
# factor for average squared gradient
beta2 = 0.999
# perform the gradient descent search with adam
best, score = adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2)
print(‘Done!’)
print(‘f(%s) = %f’ % (best, score))

예제를 실행하면 Adam 최적화 알고리즘이 테스트 문제에 적용되고 알고리즘의 각 반복에 대한 검색 성능이 보고됩니다.

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

이 경우 53번의 검색 반복 후에 거의 최적의 솔루션이 발견되었으며 입력 값이 0.0과 0.0에 가깝고 0.0으로 평가되었음을 알 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
…
>50 f([-0.00056912 -0.00321961]) = 0.00001
>51 f([-0.00052452 -0.00286514]) = 0.00001
>52 f([-0.00043908 -0.00251304]) = 0.00001
>53 f([-0.0003283  -0.00217044]) = 0.00000
>54 f([-0.00020731 -0.00184302]) = 0.00000
>55 f([-8.95352320e-05 -1.53514076e-03]) = 0.00000
>56 f([ 1.43050285e-05 -1.25002847e-03]) = 0.00000
>57 f([ 9.67123406e-05 -9.89850279e-04]) = 0.00000
>58 f([ 0.00015359 -0.00075587]) = 0.00000
>59 f([ 0.00018407 -0.00054858]) = 0.00000
Done!
f([ 0.00018407 -0.00054858]) = 0.000000

아담의 시각화

도메인의 등고선도에 Adam 검색의 진행률을 플로팅할 수 있습니다.

이는 알고리즘의 반복에 대한 검색 진행에 대한 직관을 제공할 수 있습니다.

검색 중에 찾은 모든 솔루션 목록을 유지하도록 adam()함수를 업데이트 한 다음 검색이 끝날 때이 목록을 반환해야합니다.

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

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 adam
def adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2, 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 first and second moments
 m = [0.0 for _ in range(bounds.shape[0])]
 v = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent updates
 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) = beta1 * m(t-1) + (1 – beta1) * g(t)
 m[i] = beta1 * m[i] + (1.0 – beta1) * g[i]
 # v(t) = beta2 * v(t-1) + (1 – beta2) * g(t)^2
 v[i] = beta2 * v[i] + (1.0 – beta2) * g[i]**2
 # mhat(t) = m(t) / (1 – beta1(t))
 mhat = m[i] / (1.0 – beta1**(t+1))
 # vhat(t) = v(t) / (1 – beta2(t))
 vhat = v[i] / (1.0 – beta2**(t+1))
 # x(t) = x(t-1) – alpha * mhat(t) / (sqrt(vhat(t)) + ep)
 x[i] = x[i] – alpha * mhat / (sqrt(vhat) + eps)
 # evaluate candidate point
 score = objective(x[0], x[1])
 # keep track of solutions
 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 = 60
# steps size
alpha = 0.02
# factor for average gradient
beta1 = 0.8
# factor for average squared gradient
beta2 = 0.999
# perform the gradient descent search with adam
solutions = adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2)

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

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’)

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

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
# example of plotting the adam search on a contour plot of the test function
from math import sqrt
from numpy import asarray
from numpy import arange
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 adam
def adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2, 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 first and second moments
 m = [0.0 for _ in range(bounds.shape[0])]
 v = [0.0 for _ in range(bounds.shape[0])]
 # run the gradient descent updates
 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) = beta1 * m(t-1) + (1 – beta1) * g(t)
 m[i] = beta1 * m[i] + (1.0 – beta1) * g[i]
 # v(t) = beta2 * v(t-1) + (1 – beta2) * g(t)^2
 v[i] = beta2 * v[i] + (1.0 – beta2) * g[i]**2
 # mhat(t) = m(t) / (1 – beta1(t))
 mhat = m[i] / (1.0 – beta1**(t+1))
 # vhat(t) = v(t) / (1 – beta2(t))
 vhat = v[i] / (1.0 – beta2**(t+1))
 # x(t) = x(t-1) – alpha * mhat(t) / (sqrt(vhat(t)) + ep)
 x[i] = x[i] – alpha * mhat / (sqrt(vhat) + eps)
 # evaluate candidate point
 score = objective(x[0], x[1])
 # keep track of solutions
 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 = 60
# steps size
alpha = 0.02
# factor for average gradient
beta1 = 0.8
# factor for average squared gradient
beta2 = 0.999
# perform the gradient descent search with adam
solutions = adam(objective, derivative, bounds, n_iter, alpha, beta1, beta2)
# 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()

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

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

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

추가 정보

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

논문

아담: 확률적 최적화를 위한 방법, 2014.

책

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

증권 시세 표시기

기사

요약

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

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

경사하강법은 목적 함수의 기울기를 사용하여 검색 공간을 탐색하는 최적화 알고리즘입니다.
경사하강법은 Adam이라는 편미분의 감쇠 평균을 사용하여 각 입력 변수에 대해 자동 적응형 스텝 크기를 사용하도록 업데이트할 수 있습니다.
Adam 최적화 알고리즘을 처음부터 구현하고 목적 함수에 적용하고 결과를 평가하는 방법.

Tags:

Code Adam Optimization Algorithm,Machine learning