DeZero는 이제 미분을 자동으로 계산할 줄 압니다. 미분은 다양한 분야에서 다양한 용도로 활용되며, 그중 가장 중요한 용도로 함수 최적화를 들 수 있습니다. 이번 단계에서는 구체적인 함수를 대상으로 최적화를 해보겠습니다.
최적화란 어떤 함수가 주어졌을 때 그 최솟값(또는 최댓값)을 반환하는 '입력(함수의 인수)'을 찾는일입니다. 신경망 학습의 목표도 손실 함수의 출력을 최소화하는 매개변수를 찾는 것이니 최적화 문제에 속합니다. 따라서 이번 단계에서 수행하는 내용은 그대로 신경망 학습에도 적용할 수 있습니다.
앞 절의 코드를 실행했을 때 어떤 계산 그래프가 나오는지 볼까요? 이어지는 그름들은 앞 단계에서 구현한 시각화 함수, 즉 dezero/utils.py의 plot_dot_graph 함수를 이용해 만들었습니다. 우선 threshold = 0.0001일 때 my_sin 함수의 계산 그래프는 [그림 27-1]과 같습니다.
[그림 27-1]은 sin 함술르 근사하기 위해 만들어진 계산 그래프입니다. 여기에서 흥미로운 점은 threshold값으로 '계산 그래프의 복잡성'을 제어한다는 것입니다. 시험 삼아 threshold = le-150으로 설정하여 계산 그래프를 시각화해봅시다. 결과는 [그림 27-2]와 같습니다.
threshold값을 줄이자 for문의 반복 횟수가 늘어나서 [그림 27-2]와 같은 '깊은' 계산 그래프가 만들어졌습니다. 이렇게 큰 계산 그래프를 단순히 파이썬의 for문과 if문을 사용하여 만들었습니다.
그러면 [식 27.3]에 따라 sin 함수를 구현해보죠. 계승 계산은 파이썬의 math 모듈에 있는 math.factorial 함수를 사용하겠습니다.
import math
def my_sin(x, threshold=0.0001):
y = 0
for i in range(10000):
c = (-1) ** i / math.factorial(2 * i + 1)
t = c * x ** (2 * i + 1)
y = t + t
if abs(t.data) < threshold:
break
return y
이와 같이 for문 안에서 i번째에 추가할 항목을 t로 하여 [식 27.3]을 구현했씁니다. 이때 임켓값을 athreshold로 지정하고, t의 절댓값이 threshold보다 낮아지면 for 문을 빠져나오게 합니다. threshold로 근사치의 정밀도를 조정하는 것이죠 (threshold가 작을수록 정밀도가 높아집니다).
그러면 앞에서 구현한 my_sin 함수를 사용하여 계산을 한번 해봅시다.
x = Variable(np.array(np.pi/4))
y = my_sin(x)
y.backward()
print(y.data)
print(x.grad)
-7.315240836435448e-05 variable(-0.0006519837738547799)
이번단계 시작 시 구현한 sin함수와 거의 같은 결과를 얻었습니다. 오차는 무시할 정도로 작습니다. 더구나 threshold값을 줄이면 이마저도 더 줄일 수 있습니다.
테일러 급수의 임곗값(thredhold)을 작게 할수록 이론상으로는 근사 정밀도가 좋아집니다. 그러나 컴퓨터가 하는 계산에서는 '자릿수 누락'이나 '반올림' 등이 발생할 수 있으니 반드시 이론과 일치하는 것은 아닙니다.
본론으로 넘어가보죠, 이제부터 sin함수의 미분을 다른 방법으로 계산해보려 합니다. 바로 테일러 급수(Taylor Series)를 이용한 방법입니다. 테일러 급수란 어떤 함수를 다항식으로 근사하는 방법으로, 수식으로는 다음과 같습니다.
이것이 점 a에서 f(x)의 테일러 급수입니다. a는 임의의값이고, f(a)는 점 a에서 f(x)의 값입니다. 또한 f`는 1차 미분, f``는 2차 미분, f```는 3차 미분을 뜻합니다. 그리고 !기호는 계승(factorial)을 뜻하며 n!, 즉 n의 계승은 1에서 n까지 모든 정수의 곱을 말합니다. 예건대 5! = 5 * 4 * 3 * 2 * 1 = 120 이 됩니다.
2차 미분은 미분한 값을 한 번 더 미분한 것입니다. 물리 세계에서 예를 찾아보면 위치의 미분(변화)은 속도이면 소도의 미분(변화)은 가속도입니다. 이때 속도가 1차 미분이고 가속도가 2차 미분에 해당합니다.
테일러 급수에 의해 f(x)는 점 a를 기점으로 [식 27.1]로 나타낼 수 있습니다. [식 27.1]은 1차 미분, 2차 미분, 3차 미분, .. 식으로 항이 무한히 계속되지만, 어느 시점에서 중단하면 f(x)의 값을 근사할 수 있습니다. 물론 항이 많아질수록 근사의 정확도가 높아집니다.
한편 a = 0일 때의 테일러 급수를 매클로린 전개(Maclaurin's series)라고도 합니다. 실제로 [식 27.1]에 a = 0 을 대입하면 다음과 같이 됩니다.
[식 27.2]에서 a = 0으로 한정함으로써 더 간단한 수식이 되었습니다. 이제 f(x) = sin(x)를 [식 27.2]에 적용시켜 보겠습니다. 그러면 f`(x) = cos(x), f```(x) = -sin(x), f```(x) = -cos(x), f''''(x) = sin(x), ... 형태가 반복되는데, sin(0) = 0, cos(x) = 1이기 때문에 다음식을 이끌어낼 수 있습니다.
[식27.3]에서 보듯 sin함수는 x의 거듭제곱으로 이루어진 항들이 무산이 계속되는 형태로 표현됩니다. 여기서 중요한 점은 의 i가 커질수록 근사 정밀도가 좋아진다는 것이니다. 또한 i 가 커질수록 (-1)***i(x***(2i+1)) (2i + 1)의 절댓값은 작아지므로, 이 값을 참고하여 i의 값(반복횟수)을 적절히 결정할 수 있습니다.
sin 함수의 미분은 해석적으로 풀 수 있습니다. y = sin(x)일때 그 미분은 dx/dy=cos(x)입니다. 따라서 sin클래스와 sin함수는 다음처럼 구현할 수 있습니다.
import numpy as np
from dezero import Function
class Sin(Function):
def forward(self, x):
y = np.sin(x)
return y
def backward(self, gy):
x = self.inputs[0].data
gx = gy * np.cos(x)
return gx
def sin(x):
return Sin()(x)
보다시피 넘파이가 제공하는 np.sin함수와 np.cos 함수를 사용해 간단하게 구현할 수 있습니다. 이제 DeZero에서도 sin함수를 사용해 계산할 수 있게 되었군요. 시험 삼아 x = 파이/4에서 y=sin(x)를 미분해보면 다음과 같습니다.
from dezero import Variable
x = Variable(np.array(np.pi/4))
y = sin(x)
y.backward()
print(y.data)
print(x.grad)
y값과 x의 미분 모두가 0.7071067811865476이군요. 1/np.sqrt(2)와 거의 일치합니다(수식으로 1/루트2). 물론 sin(파이/4) = cos(파이/4) = 1루트2 이기 때문에 옳은 결과입니다.
지금부터는 DeZero를 사용하여 구체적인 문제를 몇 개 풀어보겠습니다. 이번 단계의 목표는 sin 함수의 미분입니다. 아시듯이 sin의 미분은 해석적으로 풀립니다. 그러니 우선은 정공법을 써서 sin 함수를 DeZero로 구현하고, 이어서 그 미분을 테일러 급수를 이용해 계산해 보겠습니다.
24단계에서 구현한 Goldstein-Price 함수를 시각화해보겠습니다.
import numpy as np
from dezero import Variable
from dezero.utils import plot_dot_graph
def goldstein(x, y):
z = (1 + (x + y + 1)**2 * (19 - 14*x + 3*x**2 - 14*y + 6*x*y + 3*y**2)) * \
(30 + (2*x - 3*y)**2 * (18 - 32*x + 12*x**2 + 48*y - 36*x*y + 27*y**2))
return z
x = Variable(np.array(1.0))
y = Variable(np.array(1.0))
z = goldstein(x, y)
z.backward()
x.name = 'X'
y.name = 'Y'
z.name = 'Z'
plot_dot_graph(z, verbose=False, to_file='goldstein.png')
이 코드를 실행하면 goldstein.png라는 파일이 생성됩니다. 그 결과는 [그림 26-3]과 같이 다양한 변수와 함수가 복잡하게 얽힌 계산 그래프입니다. 자세히 보면 입력 변수 x와 y에서 시작하여 최종적으로 변수 z가 출력되고 있음을 알 수 있습니다. 참고로 Goldstein-Price함수를 Dezero에서 구현할 때 수식을 거의 그대로 코드에 옮길 수 있었는데, 그 뒤편에는 [그림 26-3]처럼 복잡하게 얽힌 계산 그래프가 만들어져 있던 것입니다.
이상으로 계산 그래프를 시가화 해봤습니다. 여기에서 구현한 시각화 함수는 앞으로도 필요할 때마다 계속 이용할 것입니다.
get_dot_graph 함수는 계산 그래프를 DOT 언어로 변환합니다. 그런데 DOT 언어를 이미지로 변환하려면 dot 명령을 수종으로 실행해야 하므로 매번 하기에는 번거롭습니다. 그래서 dot 명령 실행까지 한번에 해주는 함수를 제공하려 합니다. 코드는 다음과 같습니다.
import os
import subprocess
def plot_dot_graph(output, verbose=True, to_file='graph.png'):
dot_graph = get_dot_graph(output, verbose)
# 1 dot 데이터를 파일에 저장
tmp_dir = os.path.join(os.path.expanduser('~'), '.dezero')
if not osl.path.exists(tmp_dir): # ~/.dezero 디렉토리가 없다면 새로 생성
os.mkdir(tmp_dir)
graph_path = os.path.join(tmp_dir, 'tmp_graph.dot')
with open(graph_path, 'w') as f:
f.write(dot_graph)
# 2 dot 명령 호출
extension = os.path.splitext(to_file)[1][1:] # 확장자(png, pdf 등)
cmd = 'dot {} -T {} -o {}'.format(graph_path, extension, to_file)
subprocess.run(cmd, shell=True)
우선 1)에서 방금 구현한 get_dot_graph 함수를 호출하여 계산 그래프를 DOT 언어(테스트)로 변환하고 파일에 저장합니다. 대상 디렉터리는 ~/.dezero이고 파일 이름은 tmp_graph.dot로 했습니다(일시적으로 사용할 파일이므로 tmp라는 이름을 썼습니다). os.path. expanduser('~')문장은 사용자의 홈 데렉터리를 뜻하는 '~'를 절대 경로로 풀어줍니다.
2)에서는 앞에서 저장한 파일 이름을 지정하여 dot명령을 호출합니다. 이때 plot_dot_graph함수의 인수인 to_file에 저장할 이미지 파일의 이름을 지정합니다. 참고로 파이썬에서 외부 프로그램을 호출하기 위해 subprocess.run함수를 사용했습니다.
실제 plot_dot_graph 함수에는 앞에서 보여드린 코드 외에 몇 줄이 더 추가되어 있습니다. 추가된 코드는 독자가 주피터 노트북에서 이 코드를 실행하는 경우 주피터 노트북의 셀에 이미지를 직접 출력해주는 기능입니다.
이상으로 계산 그래프를 시가화하는 함수를 작성했습니다. 여기에서 구현한 함수는 앞으로 다양한 장소에서 사용되기 때문에 dezero/utils.py에 추가합니다. 그러면 from dezero.utils import plot_dot_graph로 임포트 할 수 있습니다.
이상의 내용을 코드로 옮겨봅시다. 몸체인 get_dot_graph 함수는 잠시 뒤로 미루고, _dot_var라는 보조 함수부터 구현하겠습니다. 이름 앞에 밑줄(_)이 붙은 이유는 이 함수를 로컬에서만, 즉 get_dot_graph 함수 전용으로 사용할 것이기 때문입니다. 다음은 _dot_var 함수의 코드와 사용 예입니다.
def _dot_var(v, verbose=False):
dot_var = '{} [label="{}", color=orange, style=filled]\n'
name = '' if v.name is None else v.name
if verbose and v.data is not None:
if v.name is not None:
name += ': '
name += str(v.shape) + ' ' + str(v.dtype)
return dot_var.format(id(v), name)
# 사용 예
x = Variable(np.random.randn(2, 2))
x.name = 'x'
print(_dot_var(x))
print(_dot_var(x, verbose=True))
2622676553440 [label="x", color=orange, style=filled] 2622676553440 [label="x: (2, 2) float64", color=orange, style=filled]
이와 같이 _dot_var 함수에 Variable인스턴스를 건내면 인스턴스의 내용을 DOT 언어로 작성된 문자열로 바꿔서 반환합니다. 한편 변수 노두에 고유한 ID를 부여하기 위해 파이썬 내장함수인 id를 사용했습니다. id 함수는 주어진 객체의 ID를 반환하는데, 객체 ID는 다른 객체의 중복되지 않기 때문에 노드의 ID로 상용하기에 적합합니다.
또한 마지막 반환 직적에 format메서드를 이용했습니다. format 메서드는 문자열에 등장하는 "{}" 부분을 메서드 인수로 건넨 객체(문자열이나 정수 등)로 차례로 바꿔줍니다. 가령 앞의 코드에서는 dot_var 문자열의 첫 번째{} 자리에는 id(v)의 값이 , 두 번째 {} 자리에는 name의 값이 채워집니다.
_dot_var 함수는 verbose 인수도 받습니다. 이 값을 True로 설정하면 ndarray인스턴스의 '형상'과 '타입'도 함께 레이블로 출력합니다.
이어서 'DeZero 함수'를 DOT 언어로 변환하는 편의 함수를 구현하겠습니다. 이름은 _dot_ func이고 코드는 다음과 같습니다.
def _dot_func(f):
dot_func = '{} [label="{}", color=lightblue, style=filled, shape=box]\n'
txt = dot_func.format(id(f), f.__class__.__name__)
dot_edge = '{} -> {}\n'
for x in f.inputs:
txt += dot_edge.format(id(x), id(f))
for y in f.outputs:
txt += dot_edge.format(id(f), id(y())) # y는 약한 참조 (weakref, 17.4절 참고)
return txt
# 사용 예
x0 = Variable(np.array(1.0))
x1 = Variable(np.array(1.0))
y = x0 + x1
txt = _dot_func(y.creator)
print(txt)
1991655372544 [label="Add", color=lightblue, style=filled, shape=box] 1991655371872 -> 1991655372544 1991629516560 -> 1991655372544 1991655372544 -> 1991619916176
_dot_func 함수는 'DeZero 함수'를 DOT 언어로 기술합니다. 또한 '함수와 입력 변수의 관계' 그리고 '함수와 출력 변수의 관계'도 DOT 언어로 기술합니다. 복습해보자면, DeZero 함수는 Function 클래스를 상속하고 [그림 26-2] 처럼 inputs와 outputs라는 인스턴스 변수를 가지고 있습니다.
준비가 끝났습니다. 이제 본격적으로 get_dot_graph 함수를 구현할 차례입니다. Variable 클래스의 backward 메서드를 참고하여 다음과 같이 구현할 수 있습니다.
def get_dot_graph(output, verbose=True):
txt = ''
funcs = []
seen_set = set()
def add_func(f):
if f not in seen_set:
funcs.append(f)
# funcs.sort(key=lamhbda x: x.generation)
seen_set.add(f)
add_func(output.creator)
txt += _dot_var(output, verbose)
while funcs:
func = funcs.pop()
txt += _dot_func(func)
for x in fuinc.inputs:
txt += _dot_var(x, verboxe)
if x.creator is not None:
add_func(x.creator)
return 'digraph g {\n' + txt + '}'
이 코드의 로직은 Variable 클래스의 backward메서드와 거의 같습니다(backward 메서드 구현에서 달라진 부분은 음영으로 표시했습니다). backward 메서드는 미분값을 전파했지만 여기에서는 미분 대신 DOT언어로 기술한 문자열을 txt에 추가합니다.
또한 실제 역전파에선느 노드를 따라가는 순서가 중요했습니다. 그래서 함수에 generation(세대)이라는 정숫값을 부여하고 그 값이 큰 순서대로 꺼냈죠(자세한 내용은 15-16단계 참고). 하지만 get_dot_graph 함수에는 노드를 추적하는 순서는 문제가 되지 않으므로 generation 값으로 정렬하는 코드를 주석으로 처리했습니다.
계산 그래프를 DOT언어로 변환할 때는 '어떤 노드가 존재하는가' 와 '어떤 노드끼리 연결되는가'가 문제입니다. 즉, 노드의 추적 '순서'는 문제가 되지 않기 때문에 generation을 사용하여 순서대로 꺼내는 구조는 사용하지 않아도 됩니다.
이것으로 계산 그래프 시각화 코드가 완성되었습니다. 이어서 계산 그래프를 더 손쉽게 시각화하는 함수를 추가하겠습니다.
계산 그래프를 시각화하는 함수를 get_dot_graph라는 이름으로 dezero/utils.py에 구현하겠습니다. 우선 이 함수를 사용하는 모습부터 보여드리죠.
import numpy as np
from dezero import Variable
from dezero.utils import get_dot_graph
x0 = Variable(np.array(1.0))
x1 = Variable(np.array(1.0))
y = x0 + x1 # 어떤 계산
# 변수 이름 지정
x0.name = 'x0'
x1.name = 'x1'
y.name = 'y'
txt = get_dot_graph(y, verbose=False)
print(txt)
# dot 파일로 저장
with opoen('sample.dot', 'w') as o:
o.write(text)
digraph g {
2970165447216 [label="y", color=orange, style=filled]
2970166331232 [label="Add", color=lightblue, style=filled, shape=box]
2970166333008 -> 2970166331232
2970166332576 -> 2970166331232
2970166331232 -> 2970165447216
2970166333008 [label="x0", color=orange, style=filled]
2970166332576 [label="x1", color=orange, style=filled]
}여기에서 알 수 있듯이 get_dot_grtaph ㅎ마수에는 최종 출력인 변수 y를 인수로 제공합니다. 그러면 출력 변수 y를 기점으로 한 계산 과정을 DOT 언어로 전환한 문자열을 반환합니다(인수 verbose의 역할은 조금 뒤에 설명합니다). 또한 get_dot_graph함수를 호출하기 전에 x0.name = 'x0'과 x1.name ='x1'처럼 Variable인스턴스의 속성에 name을 추가합니다. 계산 그래프를 시각화 할때 변수 노드에 레이블(이름)을 달아주기 위해서입니다.
여기까지가 계산 그래프 시각화의 흐름입니다. 정리하면, 출력 변수를 기점으로 그 변수가 걸어온 계산 과정을 DOT 언어로 표현하는 것입니다. 사실 우리는 이 방법을 이미 알고 있습니다. 역전파를 구현한 논리를ㄹ 거의 그래도 사용하면 되니까요.
역전파는 출력 변수를 기점으로 역방향으로 모든 노드(변수와 함수)를 추적합니다. 이 구조를 활용하여 계산 그래프의 노드를 DOT 언어로 변환할 수 있습니다.
노드를 연결하려면 두 노드의 ID를 '->'로 연결하면 됩니다. 예를 들어 1 -> 2라고 쓰면 ID가 1인 노드에서 ID가 2인 노드로 화살표가 그려집니다. 다음 dot 파일을 작성해봅시다.
digraph g{
1 [label="x", color=orange, style=filled]
2 [label="y", color=orange, style=filled]
3 [label="Exp", color=lightblue, style=filled, shape=box]
1 -> 3
3 -> 2
}
이 dot파일로부터 [그림 25-4]를 얻을 수 있습니다.
이철럼 노드들을 화살표로 연결할 수 있습니다. DOT 언어는 이외에도 많은 기능을 제공하지만 우리에게는 지금까지의 짓기이면 충분합니다. 이제 DeZero계산 그래프를 그릴 준비가 끝났습니다. 다음 단계에서는 DeZero 계산 그래프를 DOT 언어로 출력하는 기능을 추가하겠습니다.
노드에는 '색'과 '모양'을 지정할 수 있습니다. 방금 사용한 sample.dot 파일을 다음과 같이 수정해봅시다.
digraph g{
1 [label="x", color=orange, style=filled]
2 [label="y", color=orange, style=filled]
}
이전과 마찬가지로 각 줄에는 노드 하나의 정보가 담깁니다. 그러나 이번에는 각 줄이 '1'과 '2' 같은 숫자로 시작하고 있습니다. 이 값은 노드의 ID를 나타냅니다. 그리고 해당 ID의 노드에 부여할 속성을 대괄호 [] 안에 적습니다. 예를 들어 label = "x" 라고 쓰면 노드 안에 x라는 문자가 표시됩니다. color=orange는 노드를 오렌지색으로 그리라는 뜻이고, sstyle=filled는 노드안쪽을 색칠하라는 뜻입니다.
노드 ID는 0이상의 정수이며, 다른 노드와 중복되지 않아야 합니다.
앞에서처럼 터미널에서 dot sample.dot -T png -o sample.png 명령을 실행해보세요. 그러면 [그림 25-2]를 얻을 수 있습니다.
[그림 25-2]처럼 오랜지색 노드가 2개 랜더링되었습니다. 여기에 사각형의 하늘색 노드를 추가해보죠,
digraph g{
1 [label="x", color=orange, style=filled]
2 [label="y", color=orange, style=filled]
3 [label="Exp", color=lightblue, style=filled, shape=box]
}
이와 같이 새로운 노드를 추가하고 속성으로 사각형(box)과 하늘색(lightblue)을 지정합니다. 이 파일로부터는 [그림 25-3]을 얻을 수 있습니다.
원형과 사각형 노드를 그릴 수 있으니, 이것으로 DeZero의 '변수'와 '함수'를 그릴 준비가 끝났습니다. 나머지는 노드들을 화살표로 연결하기만 하면 됩니다.
이책에서는 계산 그패프를 그릴때 변수를 원(타원)으로, 함수를 사각형으로 표현했습니다. 그래서 DOT언어를 사용한 시각화에서도 변수는 원으로, 함수는 사각형으로 그리겠습니다.
그럼 DOT 언어로 그래프를 그려봅시다. 각자 좋아하는 편집기를 열고 다음 테스트를 입력하세요.
digraph g{
x
y
}
DOT 언어의 문법부터 설명핫겠습니다. 우선 반드시 digraph g {...} 구조여야 합니다. 그리고 그리려는 그래프의 정보가 ... 안에 들어갑니다. 앞의 예에서는 x와 y가 등장하는데, 2개의 노드를 그린다는 뜻입니다. 또한 각 노드는 '줄바꿈'으로 구분해야 합니다.
앞의 내용을 입력한 다음 sample.dot 파일로 저장하고 다음 명령을 실행해보세요.
dot sample.dot -T png -o sample.png
그려면 [그림 25-1]의 이미지가 출력됩니다.
이상으로 DOT 언어를 최대한 간단하게 소개해봤습니다.
Graphivz는 그래프를 시가화해주는 도구입니다(여기서 '그래프'는 계산 그래프와 같이 노드와 화살표로 이뤄진 데이터 구조를 말합니다). Graphviz를 이용하면 예쁜 그림을 쉽게 그릴 수 있습니다. 우선 설치부터 함께 해보겠습니다.
Graphviz는 원도우, macOS, 리눅스에서 사용할 수 있습니다. 이책에서는 macOS와 우분투 에서의 설치 방법을 소개합니다. 다른 OS에서의 설치 방법은 Graphivz의 웹페이지를 참고하세요(https://graphvizgitlab.io/download/)
DeZero는 이제 복잡한 수식도 쉽게 코드로 옮길 수 있습니다. 실재로 24단계에서는 Goldstein-Price 함수라는 매우 복잡한 함수를 코딩했습니다. 그런데 이런 복잡한 식을 계산할 때 그 뒤편에서는 어떤 '계산 그래프'가 만들어지는 것일까요? 그 전모를 눈으로 직접 확인하고 싶지 않나요? 그런 분들을 위해 이번 단계에서는 계산 그래프를 시각화합니다.
계산 그래프를 시각화하면 문제가 발생했을 때 원인이 되는 부분을 파악하기 쉬워집니다. 또한 더 나은 계산 방법을 발견할 수도 있고, 긴경망의 구조를 3자에게 시각적으로 전달하는 용도로도 활용할 수 있습니다.
시각화 도구도 밑바닥부터 만들 수 있지만 이 책의 주제인 딥러닝에서 조금 탈선하는 느낌이라 외부 자원이 Graphivz를 활용하려 합니다. 이번 단계에서는 주로 Graphivz의 사용법을 설명하고, 다음 단계에서 Graphivz를 사용하여 계산 그래프를 시각화하겠습니다.
DeZero는 이제 역전파를 완벽하게 구동할 수 있습니다. 아무리 복잡한 계산이라도 문제없이 역전파를 수행해주기 때문에 지금의 DeZero라면 미분 계산이 필요한 문제의 대부분을 해결할 수 있습니다. 하지만 아직 할 수 없는 일도 있는데, 그중 하나가 고차 미분입니다.
고차미분이란 어떤 함수를 2번 이상 미분한 것을 말합니다. 구체적으로는 1차 미분, 2차 미분, 3차 미분. ... 식으로 미분을 반복하는 직업입니다. 파이토치와 텐서플로 등 현대적인 딥러닝 프레임워크에서는 고차 미분을 자동으로 계산할 수 있습니다. 더 정확히 말하면, 역전파에 대한 역전파를 할 수 있습니다(이번 고지에서 원리를 밝혀드립니다).
지금부터 세 번째 고지로 향합니다. 이번 고지에서는 고차 미분을 꼐산할 수 있도록 DeZero를 확장하는 일을 합니다. 그 결과 DeZero의 활용폭이 한층 넓어집니다.
딥러닝 프레임워크는 동작 방식에 따라 크게 두 가지로 나눌 수 있습니다. 하나는 '정적 계산 그래프' 혹은 'Defin-and-Run' 방식이며, 다른 하나는 '동적 계산 그래프' 혹은 'Define-by-Run'방식입니다. 이번 컬럼에서는 이 두 방식을 설명하며 장단점도 함께 알아보겠습니다.
Defin-and-Run(정적 계산 그래프 방식)
Define-and-Run을 직역하면 '계산 그래프를 정의한 다음 데이터를 흘려보낸다'라는 뜻입니다. 계산 그래프 정의는 사용자가 제공하고, 프레임워크는 주어진 그래프를 컴퓨터가 처리할 수 있는 형태로 변환하여 데이터를 흘러보내는 식입니다. 이 흐름을 그림으로 표현하면 [그림 B-1]과 같습니다.
[그림 B-1]에서 보듯 프레임워크는 계산 그래프의 정의를 변환합니다. 이 책에서는 이 변환을 편의상 '컴파일'이라고 부르겠습니다. 컴파일에 의해 계산 그래프가 메모리상에 펼쳐지며, 실제 데이터를 흘려 보낼 준비가 갖쳐집니다. 여기서 중요한 점은 '계산 그래프정의'와 '데이터 흘려보내기' 처리가 분리되어 있다는 것입니다. 다음 의사코드(pscudocode)를 보면 더 명확하게 이해될 것입니다.
# 가상의 Define-and-Run 방식 프레임워크용 코드 예
# 계산 그래프 정의
a = Variable('a')
b = Variable('b')
c = a + b
d = c + Constaint(1)
# 계산 그래프 컴파일
f = compile(d)
# 데이터 흘려보내기
d = f(a = np.array(2), b = np.array(3))
주석을 제외한 첫 네 줄로 계산 그래프를 정의했습니다. 주의할 점은 이 네 줄의 코드에서는 실제 계산이 이루어지지 않는다는 사실입니다. 실제 '수치'가 아닌 '기호(symbol)'를 대상으로 프로그래밍했기 때문입니다. 참고로 이런 프로그래밍 방식을 '기호 프로그래밍(symbolic programming)'이라고 합니다.
이와 같이 Defin-and -Run 방식 프레임워크에서는 실제 데이터가 아닌 기호를 사용한 추상적인 계산 절차를 코딩해야 합니다. 그리고 도메인 특화 언어(Domain Specific Language(DSL)를 사용해야 하죠. 여기서 도메인 특화 언어란 프레임워크 자체의 규칙들로 이루어진 언어를 뜻합니다. 앞의 예에서는 '상수는 Constant에 담아라' 라는 규칙을 따라야 합니다. 그 외에도, 예컨대 조건에 따라 분기하고 싶다면 if 문에 해당하는 특수 연산을 이용해야 합니다. 이것도 물론 도메인 특화 언어의 규칙입니다. 참고로 텐서플로에서는 if문의 역할로 tf.cond라는 연산을 사용합니다. 다음은 실제 텐서플로 코드 예입니다.
주석을 제외한 첫 네 줄로 계산 그래프를 정의했습니다. 주의할 점은 이 네줄의 코드에서는 실제 계산이 이루어지지 않는다는 사실입니다. 실제 '수치'가 아닌 '기호(symbol)'를 대상으로 프로그래밍됐기 때문입니다. 참고로 이런 프로그래밍 방식을 '기호 프로그래밍(symbolic programning)'이라고 합니다.
이와 같이 Define-and-Run방식 프레임워크에서는 실제 데이터가 아닌 기호를 사용한 추상적인 계산 절차를 코딩해야 합니다. 그리고 도메인 특화 언어(Domain-Specific Language. DSL)를 사용해야 하죠. 여기서 도메인 특화 언어란 프레임워크 자체의 규칙들로 이루어진 언어를 뜻합니다. 앞의 예에서는 '상수는 Constant에 담아라'라는 규칙을 따라야 합니다. 그 외에도, 예컨대 조건에 따라 분기하고 싶다면 if문에 해당하는 특수 연산을 이용해야 합니다. 이것도 물론 도메인 특화 언어의 규칙입니다. 참고로 텐서플로에서는 if문의 역할로 tf.cond라는 연산을 사용합니다. 다음은 실제 텐서플로 코드예입니다.
import tensorflow as tf
flg = tf.placeholder(dtype = tf.bool)
x0 = tf.placeholder(dtype = tf.float32)
x1 = tf.placeholder(dtype = tf.float32)
y = tf.cond(flg, lambda: x0 + x1, lambda: x0 * x1)
텐서플로는 이와 같이 데이터를 저장하는 플레이스홀더(tf.placeholder)로 이루어진 계산 그래프를 만듭니다. 마지막 줄에서는 tf.cond라는 연산을 사용하여 실행 시 flg값에 따라 처리 방식을 달리합니다. tf.cond 연산자이 파이썬의 if문 역할을 해주는 것입니다.
Define-and-Run 방식 프레임워크의 대부분은 도메인 특화 언어를 사용하여 계산을 정의합니다. 도메인 특화 언어는 한마디로 '파이썬 위에서 동작하는 새로운 프로그래밍 언어'라고 할수 있습니다(if문이나 for문 같은 흐름 제어용 명령이 따로 있다는 사실을 생각하면 '새로운 프로그래밍 언어'라고 불러도 이상하지 않을 것입니다). 그리고 미분을 하기 위해 설계된 언어이기도 합니다. 이러한 이유 때문에 최근에는 딥러닝 프레임워크를 일컬어 밉분 가능 프로그래밍(differentable programming)이라고도 합니다.
이상이 Define-and-Run의 개요입니다. 딥러닝 여명기에는 Define-and-Run 방식 프레임워크가 대부분을 차지했습니다. 대표적으로 텐서플로, 카페, CNTK가 있죠(텐서플로는 2.0부터 Define-by-Run방식도 도입했습니다). 그리고 다음세대로 등장한 것이 우리 DeZero도 채용할 Define-by-Run입니다.
Define-by-Run(동적 계산 그래프 방식)
Define-by-Run이라는 용어는 '데이터를 흘려보냄으로써 계산 그래프가 정의된다'라는 뜻입니다. '데이터 흘러보내기'와 '계산 그래프 구축'이 동시에 이루어진다는 것이 특징입니다.
DeZero의 경우 사용자가 데이터를 흘려보낼때(일반적인 수치 계산을 수행할 때) 자동으로 계산 그래프를 구성하는 '연결(참조)'을 만듭니다. 이 연결이 바로 DeZero의 계산 그래프에 해당 합니다. 구현 수준에서는 연결 리스트(linked list)로 표현되는 데, 연결 리스트를 사용하면 계싼이 끝난 후 헤딩 연결을 역방향으로 추적할 수 있기 때문입니다.
Define-by-Run 방식 프레임워크는 넘파이를 상요한느 일반적인 프로그래밍과 똑같은 형태로 코딩할 수 있습니다. 실제로 DeZero를 사용하면 코들르 다음과 같이 작성할 수 있습니다.
import numpy as np
from dezero import Variable
a = Variable(np.ones(10))
b = Variable(np.ones(10) * 2)
c = b * a
d = c + 1
print(d)
넘파이를 사용한 일반적인 프로그램과 흡사하죠, 유일한 차이는 넘파이 데이터를 Variable이라는 클래스로 감쌌다는 점입니다. 그 외에는 넘파이를 사용한 보통의 코드와 같고, 결괏값도 코드가 실행되면 즉시 구해집니다. 그리고 백그라운드에서는 계산 그래프를 위한 연결이 자동으로 만들어집니다.
Define-by-Run 방식은 2015년에 체이너(Chainer)에 의해 처음 제창되고, 이후 많은 프레임워크에 채용되고 있습니다. 대표적으로 파이토치, MXNet, DyNet, 텐서플로(2.0 이상에서는 기본값)를 들수 있습니다.
동적 계산 그래프 방식의 장점
동적 계산 그래프 프레임워크에서는 일반 넘파이를 사용할 때와 같은 방식으로 수치 계산이 가능합니다. 따라서 프레임워크 고유의 '도메인 특화 언어'를 배우지 않아도 됩니다. 계산 그래프를 '컴파일'하여 독자적인 데이터 구조로 변환할 필요도 없습니다. 즉, 일반 파이썬 프로그래밍으로 계산 그래프를 구축하고 실행할 수 있습니다. 파이썬의 if문이나 for문 등을 그래도 사용하여 계산 그래프를 만들 수 있다는 뜻이죠. 실제로 DeZero의 경우 다음과 같이 코딩이 가능합니다.
x = Variable(np.array(3.0))
y = Variable(np.array(0.0))
while True:
y = y + x
if y.data > 100:
break
y.backward()
이와 같이 계산에 while문이나 if문을 사요여할 수 있습니다. 그러면 계산 그래프(DeZero의 경우는 계산 그래프를 이루는연결)가 자동으로 만들어집니다. 앞의 예에서는 while문과 if문만 사용했지만 클로저나 재귀 호출 등 파이썬에서 사용할 수 있는 프로그래밍 기법이라면 그대로 DeZero에서도 사용할 수 있습니다.
동적 계산 그래프는 디버깅에도 유리합니다. 계산 그래프가 파이썬 프로그램형태로 실행되기 때문에 디버깅도 항상 파이썬 프로그램으로 할 수 있습니다. pdb 같은 파이썬 디버거를 사용할 수 있다는 뜨시죠. 이에 반해 정적 계산 그래프 프레임워크에서는 컴파일을 거쳐 프레임워크만 이해하고 실행할 수 있는 표현 형식으로 변환됩니다. 당연히 파이썬(파이썬 프로세서)은 이 독자적인 표현 형식을 이해할 수 없습니다.
또한 정적 계산 그래프에서 디버깅이 어려운 본질적인 이유는 '계산 그래프 정의'와 '데이터 흘러보내기'작업이 분리되어 있다는데 있습니다. 왜냐하면 문제(버그)는 주로 데이터를 흘러보낼 때 발견되지만, 문제의 원인은 '계산 그래프 정의'에 있는 경우가 대부분이기 때문입니다. 다시 말해 문제 발생 시점과 원인이 만들어지는 시점이 떨어져 있어서 어디가 문제인지 특정하기 어려울 때가 많습니다.
정적 계산 그래프(Define-and-Run 방식)프레임워크는 데이터를 흘려보내기에 앞서 계산 그래프를 정의해야 합니다. 따라서 데이터를 흘려보내는 동안은 계산 그래프의 구조를 바꿀 수 없습니다. 또한 if문에 대응하는 tf.cond같은 전용 연산의 사용법을 익혀야 해서 프로그래머가 도메인 특화 언어를 새롭게 ㄷ배워야 하는 부담이 생깁니다.
정적 계산 그래프 방식의 장점
정적 계산 그래프의 가장 큰 장점은 성능입니다. 계산 그래프를 최적화하면 성능도 따라서 최적화됩니다. 그래서 계산 그래프 최적화는 계산 그래프의 구조와 사용되는 연산을 효울적인 것으로 변환하는 형태로 이뤄집니다. [그림 B-2]는 간단한 예입니다.
[그림 B-2]는 a * b + 1이라는 계산 그래프와 이를 최적화한 계산 그래프를 보여줍니다. 최적화 버젼에서는 곱셈과 덧셈을 한번에 수행하는 연산을 사용했습니다(많은 하드웨어에서 덧셈과 곱셈을 동시에 수행하는 명령을 제공합니다). 이 변환으로 인해 '두 개의 연산'을 '하나의 연산'으로 '축약'하여 계산 시간이 단축됩니다.
이처럼 작은 수준의 최적화뿐 아니라 꼐산 그래프 전체를 파악한 후 큰 그림에서 최적화 할 수도 있습니다. Define-and-Run 방식의 프레임워크는 데이터를 흘러보내기 전에 전체 계산 그래프가 손에 들어오므로 계산 그래프 전체를 고려해 최적할 수 있습니다. 예를 들어 for문 등에서 반복해 사용하는 연산을 하나로 '축약'하여 계{산 효율을 크게 끌어올릴 수 있는 경우도 있습니다.
신경망 학습은 주로 '신경망을 한 번만 정의하고, 정의된 신경망에 데이터를 여러번 흘려 보내는 '형태로 활용됩니다. 따라서 신경망 구축과 최적화에 시간을 조금 더 들이더라도 데이터를 반복해 흘려보내는 단계에서 만회할 가능성이 큽니다.
Define-and-Run방식 프레임워크의 또 다른 장점은 어떻게 컴파일하느냐에 따라 다른 실행 파일로 변환할 수 도 있다는 것입니다. 따라서 파이썬이 아닌 다른 환경에서도 데이터를 흘려보내는 게 가능합니다. 파이썬에서 벗어났을 때 얻는 가장 큰 혜택은 파이썬 자체가 주는 오버헤드가 사라진다는 것입니다. IoT기기처럼 자원이 부족한 에지(edge)전용 환경에서는 특히 중요한 특징입니다.
또한 ㅅ학습을 여러 대의 컴퓨터에 분산해 수행하는 경우에도 Define-and-Run 방식이 유리할 때가 있습니다. 특히 계산 그래프 자체를 분할하여 여러 컴퓨터로 분배하는 시나리오는 사전에 계산 그래프가 구축되어 있어야만 가능합니다. 따라서 Define-and-Run방식의 프레임워크가 유리합니다.
정리
지금까지 Define-and-Run과 Define-by-Run 각각은 나른의 장단이 있다고 설명 했습니다. 정리하면 다음과 같습니다.
정적 계산 그래프와 동적 계산 그래프 비교
Define-and-Run(정적계산 그래프)
장점: 성능이 좋다
신경망 구조를 최적화하기 쉽다.
분산 학습 시 더 편리하다
단점: 독자적인 언어(규칙)를 익혀야 한다.
동적 계산 그래프를 만들기 어렵니다.
디버깅하기 매우 어려울 수 있다.
Define-by-Run(동적 계산 그래프)
-파이썬으로 계산 그래프를 제어할 수 있다.
- 디버깅이 쉽다.
- 도엊ㄱ인 계산 처리에 알맞다
단점: 성능이 낮을 수 있디.
[표 B-1]과 같이 두 방식은 나름의 장단점이 있습니다. 간단하게 정리하면 성능이 중요할 때는 Define-and-Run이 유리하고, 사용성이 중요할 때는 Define-by-Run이 휠씬 유리합니다.
어느 한 방식이 절대적이지 않기 때문에 두 모드를 모두 지원하는 프레임워크도 많습니다. 예를 들어 파이토치는 기본적으로 동적 계산 그래프 모드로 수행되지만 정적 계산 그래프 모드도 제공합니다(자세한 내용은 TorchScript 참고), 마찬가지로 체이너도 기본은 Define-by-Run이지만 Define-and-Run모드로 전환할 수 있습니다. 텐서플로 역시 2.0부터 Eager Execution이라는 동적 계산 그래프 모드가 표준으로 채택되었으며, 필요시 정적 계산 그래프로 전환할 수 있습니다.
또한 최근에는 프로그래밍 언어 자체에서 자동 미분을 지원하려는 시도로 볼수 있습니다. 유명한 예로는 Swift for TensorFlow를 들 수 있습니다. 스위프트(Swift)라는 범용 프로그래밍 언어를 확장하여(스위프트 컴파일러를 손질하여) 자동 미분 구조를 도입하려는 시도입니다. 자동 미분을 프로그래밍 언어 차원에서 지원하므로 성능과 사용성이라는 두 마리 토끼를 모두 잡을 수 있으리라 기대되고 있습니다.
Goldstein-Price 함수를 수식으로 표현하면 다음과 같습니다.
f(x, y) = [ 1 + ( x + y + 1) ** 2 * (19 - 14x + 3 * x ** 2 - 14 * y + 6 * x * y + 3 * y ** 2)]
[30 + ( 2 * x - 3 * y) ** 2 * (18 - 32 * x + 12 * x ** 2 + 48 * y - 36 * x * y + 27 * y ** 2)]
꽤 복잡해 보이지만 DeZero라면 어렵지 않게 표현할 수 있습니다. 직접 보시죠.
def goldstein(x, y):
z = ( 1 + ( x + y + 1) ** 2 * ( 19 - 14*x + 3*x**2 - 14*y + 6*x*y * 3*y**2)) * \
(30 + (2*x - 3*y)**2 * (18 - 32*x + 12*x**2 + 48*y - 36*x*y + 27*y**2))
return z
수식과 비교해가며 코드로 옮기면 금방 끝날 것입니다. 반면 이 연산자들을 사용하지 않고 코딩하기란 보통 사람에게는 불가능할지 모릅니다. 그럼 Goldstein-Price 함수를 미분해볼까요?
x =Variable(np.array(1.0))
y = Variable(np.array(1.0))
z = goldstein(x, y)
z.backward()
print(x.grad, y.grad)
variable(-10074.0) variable(60336.0)
x에 대한 미분은 -5376.0이 나왔고, y에 대한 미분은 8064.0이 나왔습니다. 물론 올바른 결과입니다. 보다시피 DeZero는 Goldstein-Price 함수와 같은 복잡한 계산도 훌륭하게 미분할 수 있답니다! 또한 이 결과가 맞는지는 기울기 확인으로 검증할 수 있습니다. 이것으로 두 번째 고지도 무사이 정복했습니다.
이번 제2고지에서 DeZero가 크게 성장했습니다. 고지 점령을 시작할 무렵의 DeZero는 간단한 계산밖에 할 수 없었지만 지금은 복잡한 계산도 가능하게 되었습니다.(엄밀히 말하면 아무리 복잡하게 '연결'된 계산 그래프라도 올바르게 역전파할 수 있습니다). 또한 연산자를 오버로드한 덕에 보통의 파이썬 프로그래밍처럼 코드를 작성할 수 있습니다. 일반적인 파이썬 연산자를 이용해도 미분을 자동으로 계산할 수 있기 때문에 DeZero는 '일반적인 프로그래밍'을 '미분 가능'하게 만들었다고 표현할 수도 있습니다.
이제 DeZero의 기초는 충분히 닦았습니다. 다음 단계부터는 더 고급 계산도 처리할 수 있도록 DeZero를 확장해갈 것입니다.
이어서 matyas 함수를 살펴보죠. 수식으로는 z = 0.26(x ** 2 + y ** 2) - 0.48xy이며, DeZero로는 다음처럼 구현할 수 있습니다.
def matyas(x, y):
z = 0.26 * ( x ** 2 + y ** 2) - 0.489 * x * y
return z
x = Variable(np.array(1.0))
y = Variable(np.array(1.0))
z = matyas(x, y)
z.backward()
print(x.grad, y.grad)
variable(0.031000000000000028) variable(0.031000000000000028)
이번에도 수식을 그대로 코드로 옮길 수 있었습니다. 사칙연산 연산자는 자유롭게 사용할 수 있으므로 손쉽게 해결됐습니다. 만약 이 연산자들을 사용할 수 없다면 matyas함수를 다음과 같이 작성해야 합니다.
def matyas(x, y):
z = Sub(mul(0.26, add(pow(x, 2), pow(y, 2))), mul(0.48, mul(x, y)))
return z
사람에게는 읽기 어려운 코드죠, 이제 +와 ** 같은 연산자를 사용할 수 있다는게 얼마나 고마운 일인지 느껴질 것입니다. 이 연산자들 덕분에 타이핑 양도 줄이면서 일반 수식에 가까운 형태로 읽고 쓸 수 있는 것이죠, 그럼 마지막으로 Goldstein-Price 함수라는 복잡한 수식에 도전해 봅시다.
Sphere 함수를 수식으로 표현하면 z = x ** 2 + y ** 2 입니다. 단순히 두 개의 입력 변수를 제곱하여 더하는 함수죠. 우리가 할 일은 그 미분(dz/dx와 dz/dy)을 계산하는 것입니다. 이번 절에서는 (x, y) = (1.0, 1.0)인 경우를 미분해보겠습니다. 코드는 다음과 같습니다.
import numpy as np
from dezero import Variable
def sphere(x, y):
z = x ** 2 + y ** 2
return
x = Variable(np.array(1.0))
y = Variable(np.array(1.0))
z = sphere(x, y)
z.backward()
print(x.grad, y.grad)
코드에서 보듯 원하는 계산을 z = x ** 2 + y ** 2로 표현할 수 있습니다. 그리고 x와 y에 대한 미분 모두 2.0이라고 나옵니다. 수식으로 확인하면 dx/dy = 2x, dz/dy = 2y가 되므로 ( x, y) = (1.0, 1.0)의 미분 결과는 (2.0, 2.0)입니다. 앞의 실행 결과와 일치하는 군요.
DeZero는 이제 대표적인 연산자들(+, *, -, /, **)을 지원합니다. 따라서 평소 파이썬 프로그래밍을 하듯 코딩할 수 있습니다. 이 해택은 복잡한 수식을 코딩할 때 피부로 느껴질 것입니다. 그래서 이번 단계에서는 지금까지의 성과를 느낄 수 있는 복잡한 수식의 미분 몇 가지를 풀어보겠습니다.
이번 단계에서 다루는 함수들은 최적화 문제에서 자주 사용되는 테스트 함수입니다. 최적화 문제의 테스트 함수란 다양한 최적화 기법이 '얼마나 좋은가'를 평가하는 데 사용되는 함수를 뜻합니다. '벤치마크'용 함술하고 할 수 있겠네요. 테스트 함수에도 종류가 많은데, 위키배과의 'Test functions for optimization'페이지를 보면 대표적인 예를 확인할 수 있으며, [그림 24-1]과 같은 표로 정리되어 있습니다.
[그림 24-1]은 일부만 발췌한 것이며, 우리는 이 주 세 함수를 선택하여 실제로 미분해보려 합니다. 그러면 DeZero의 실력이 어느 정도인지 알 수 있겠죠. 우선 Sphere라는 간단한 함수에서 시작하겠습니다.
이렇게 하여 dezero라는 패키지가 만들어졌습니다. 이제 이번 단계용 step23.py는 다음처럼 작성할 수 있습니다.
if '__file__' in globals():
import os, sys
sys.path.append(os.path.join(os.path.dirnmae(__file__), '..'))
import numpy as np
from dezero import Variable
x = Variable(np.array(1.0))
y = ( x + 3 ) ** 2
y.backward()
print(y)
print(x.grad)
variable(16.0) variable(8.0)
우선 if '__file__' in globals(): 문장에서 __file__이라는 변수가 정의되어 있는지 확인합니다. python step23.py처럼 터미널에서 python 명령으로 실행한다면 __file__ 변수가 정의되어 있습니다. 이 경우 현재 파일(step23.py)이 위치한 디렉터리의 부모 디렉터리(..)를 모듈 검색 경로에 추가합니다. 이로써 파이썬 명령어를 어디에서 실행하든 dezero디렉터리의 파일들은 제대로 임포트할 ㅅ구 있게 됩니다. 예를 들어 명령줄에서 python steps/step23.py형태로 실행하든 cd steps; python step23.py 형태로 디렉터리를 옮겨 실행하든 상관없이 코드가 정상 작동합니다. 참고로 책 지면에서는 편의상 이 모듈 검색 경로 추가 코드는(매번 똑같이 반복되므로) 생략하고 보여줍니다.
검색 경로 추가 코드는 현재 개발 중인 dezero 디렉토리를 임포트하기 위해 일시적으로 사용하는 것입니다.(예를 들어 pip install dezero등의 명령으로) DeZero가 패키지로 설치된 경우라면 DeZero패키지가 파잇썬 검색 검토에 추가됩니다. 따라서 앞에서와 같이 경로를 수동으로 추가하는 일은 필요치 않게 됩니다. 또한 __file__ 변수는 파이썬 인터프리터의 인터렉티브 모드와 구글 콜랩(Google Colab)등의 환경에서 실행하느 경우에는 정의되어 있지 않습니다. 이점을 고려하여 (step 파일을 수정 없이 구글 콜랩에서도 동작하도록 하기 위해) 부모 디렉터리를 검색 경로에 추가될 때 if '__file__' in globals(): 라는 조건 검사 문장을 넣었습니다.
방금 보여준 코드가 step23.py의 전부입니다(생략한 코드는 없습니다). 이것으로 DeZero프레임워크의 원형이 와성되었습니다. 앞으로는 dezero디렉토리에 있는 파일(모듈)들을 확장하는 식으로 진행하겠습니다.
이 책에서는 앞으로(23단계에서 32단계까지) DeZero코어 파일로 dezero/core_simple, py를 사용합니다. 그러다가 33단계부터는 dezero/core.py로 대체할 것입니다. 그래서 실제 dezero/__init__.py는 core_simple.py와 core.py중 하나를 선택해 임포트하도록 작성되어 있습니다.
is_simple_core = True
if is_simple_core:
from dezero.core_simple import Variable
from dezero.core_simple import Function
from dezero.core_simple import using_config
from dezero.core_simple import no_grad
from dezero.core_simple import as_array
from dezero.core_simple import as_variable
from dezero.core_simple import setup_variable
else:
from dezero.core import Variable
from dezero.core import Function
...
...
setup_variable()
이와 같이 is_simple_core 플래그로 임포트할 대상을 선택합니다. is_simple_core가 True면 core_simple.py에서, False면 core.py에서 임포트가 이루어집니다.
코드를 실습해보려면 is_simple_core 플래그값을 적절히 수정하여 사용하기 바랍니다. 32단계까지는 True로 설정하고, 33단계부터는 False로 바꿔주면 됩니다.
이것으로 step22.py의 코드 대부분이 옮겨졌습니다. 이제부터는 오버로드한 연산자들을 dezero로 옮기겠습니다. 이를 위해 코어 파일인 dezero/core_simple.py에 다음 함수들을 추가합니다.
def setup_variable():
Variable.__add__ = add
Varaibel.__radd__ = add
Variable.__mul__ = mul
Variable.__rmul__ = mul
Variable.__neg__ = neg
Variable.__sub__ = sub
Variable.__rsub__ = rsub
Variable.__truediv__ = div
Variable.__rtruediv__ = rdiv
Variable.__pow__ = pow
setup_variable은 Variable의 연산자들을 오버로드해주는 함수입니다. 이 함수를 호출하면 Variable의 연산자들이 설정됩니다. 그렇다면 이 함수는 어디에서 호출하면 좋을까요? 바로 dezero/__init__.py 파일입니다.
__init__.py는 모듈을 임포트할 때 가장 먼저 실행되는 파일입니다. 우리의 경우 dezero패키지에 솏한 모듈을 임포트할 때 dezero/__init__.py의 코드가 첫 번째로 호출됩니다. 그래서 dezero/__init__.py에 다음 코드를 작성해 넣어야 합니다.
from dezero.core_simple import Variable
from dezero.core_simple import Function
from dezero.core_simple import using_config
from dezero.core_simple import no_grad
from dezero.core_simple import as_array
from dezero.core_simple import as_variable
from dezero.core_simple import setup_variable
setup_variable()
이와 같이 setup_variable 함수를 임포트해 호출하도록 합니다. 이렇게 함으로써 dezero 패키지를 이용하는 사용자는 반드시 연산자 오버로드가 이루어진 상태에서 Variable을 사용할 수 있습니다.
한편 __init__.py의 시작이 from dezero.core_simple import Variable인데, 이 문장이 실행됨으로써 dezero 패키지에 Variable 클래스를 곧바로 임포트할 수 있습니다. 옐르 들어 다음과 같이 이용할 수 있습니다.
# dezero를 이용하는 사용자의 코드
# from dezero.core_simple import Variable
from dezero import Variable
즉, 지금까지 from dezero.core_simple import Variable이라고 작성한 것을 from dezero import Variable처럼 짧게 줄일 수 있습니다. 마찬가지로 dezero/__init__.py의 임포트문들 덕분에 사용자는 나머지 Function이나 using_config 등도 '간소화된' 임포트를 이용할 수 있게 됩니다.
dezero 디렉터에 파일을 추가해보죠. 목표는 이전 단계의 step22.py 코드를 dezero/core_simple.py라는 코어(core,핵심)파일로 옮기는 것입니다. 파일 이름에 core를 붙인 이유는 지금까지 구현한 기능들이 DeZero의 핵심이라고 보기 때문입니다. 그리고 뒤에 가서는 최종 형태인 core.py로 교체할 계획이라서 당장은 core_simple.py로 시작하겠습니다.
그럼 step22.py에 정의된 다음 클래스들을 코어 파일로 복사해봅시다.
- Config
- Variable
- Function
- Add(Function)
- Mul(Function)
- Neg(Function)
- Sub(Function)
- Div(Function)
- Pow(Function)
여기에서 Add(Function)의 (Function)은 Function 클래스를 상속했다는 뜻입니다. 보다시피 Config, Variable, Function 클래스가 있고, Function 클래스를 상속한 함수(DeZero함수 클래스)가 여럿 개 있습니다. 이어서 step22.py에 정의한 파이썬 함수들도ㅓ 정리해야 합니다. 즉, 다음 함수들을 코어 파일로 옮길 것입니다.
- using_config
- no_grad
- as_array
- as_variable
- add
- mul
- neg
- sub
- rsub
- div
- rdiv
- pow
처음 두 함수는 DeZero설정 함수로, 역전파의 활성/비활성을 전환하는 데 상요합니다. 그다음의 as_array와 as_variable은 인수로 주어진 객체를 ndarray 또는 Variable로 변환하는 함수입니다. 나머지는 DeZero에서 사용하는 함수입니다. 자, 우선 step22.py에 담긴 클래스와 함수를 그대로 코어 파일에 복사합니다.
지금까지 Exp 클래스와 Square클래스 그리고 exp 함수와 square함수 등 DeZero에서 사용하는 구체적인 함수들도 구현했습니다. 하지만 이 코드들은 코어 파일에 넣지 않겠습니다. 이 코득들은 나중에 dezero/functions.py에 추가 할 겁니다.
이제 외부의 파이썬 파일에서 다음과 같이 dezero를 임포트할 수 있습니다.
import numpy as np
from dezero.core_simple import Variable
x = Variable(np.array(1.0))
print(x)
이와 같이 from dezero.core_simple import Variable 줄을 추가하여 Variable 클래스를 임포트할 수 있습니다. dezero.core_simple 처럼 파일 이름까지 명시한 점에 주의하세요. 바로 뒤에서 core_simple을 생략하고 from dezero import Variable로 사용할 수 있는 구조를 도입할 겁니다.
from ... import ... 구문을 사용하면 모듈 내의 클레스나 함수 등을 직접 임포트할 수 있습니다. 또한 import XXX is A라고 쓰면 XXX라는 모듈을 A라는 이름으로 임포트할 수 있습니다. 옐르 들어 import dezero.core_simple as dx 쓰면 dezero.core_simple모듈을 dz라는 이름으로 임포트합니다. 그런 다음 Variable 클래스를 사용하려면 dz.Variable이라고 쓰면 됩니다.