Eager execution Vs Graph execution

해당 포스트에서는 Tensorflow의 Eager execution 과 Graph execution의 차이점을 아래 주제로 설명합니다.

• Debug
• 변수 관리
• Computation Speed

Debug

Graph Execution Mode

Tensorflow 2.x 버전으로 업데이트 되면서
Tensorflow 는 Eager Excution 이라는 Tensorflow 1.x 에 없던 새로운 개념을 도입합니다.

기존의 Tensorflow 1.x 은 Graph 을 생성 한 후
해당 그래프와 연결된 Session 을 생성하고 Session 을 통해 실행하고자 하는 Tensor 또는 Operation 을 수행해 원하는 결과를 얻는 과정을 수행 하였습니다.
아래 에제 코드를 살펴 봅시다.

# create new graph 
g = tf.Graph()

# set graph to default graph 
# add node, tensor to graph 
with g.as_default():
  a = tf.constant(3)
  b = tf.constant(5)
  c = a + b

# create session with graph g 
sess = tf.Session(graph=g)

# get result from tensor c 
sess.run(c)

위 예제에서 4가지 단계로 Tensorflow 1.x 가 수행되는 것을 알수 있습니다.

1. Graph 생성
2. Graph 에 노드 및 텐서 추가
3. Session 생성 및 Session과 Graph 연동
4. 수행하고 자 하는 Tensor 수행

하지만 Tensorflow 1.x 의 코드 구현 방식은 Python 의 장점을 충분히 살리지 못하는 단점이 있습니다.
Python 은 Interpreter 언어로서 실행 결과를 바로바로 알수 있습니다.
이를 통해 디버그도 매우 편하다는 장점을 가지고 있습니다.

하지만 Graph 을 모두 생성한 후 Session 을 통해 원하는 결과를 얻어야 하는 Tensorflow 1.x는 바로 바로 결과를 확인할 수 없습니다. 이는 코드 디버그를 어렵게 합니다.

Tensorflow 1.x 버전에서의 Debug 방법으로 Tensorboard 또는 tfdbg을 추천합니다.

Eager Execution mode

Tensorflow 2.x 버전에서는 Tensorflow 1.x 의 단점을 극복하고자 Eager execution 기능을 기본 모드로 제공합니다.
Eager Execution 모드는 Graph을 생성하지 않고 계산값을 바로바로 알려주는 명령형(imperative) 프로그래밍 환경입니다.

Eager Execution 모드는 python 코드를 작동시키는 일반적인 과정과 매우 유사합니다. 즉 한줄 한줄 바로 실행하면서 바로 결과를 확인해 볼 수 있습니다.

a = tf.constant(3)
b = tf.constant(5)
c = a + b

그렇기에 위 그림처럼 텐서 안에 있는 값들을 바로바로 확인 가능합니다.

변수 관리

Graph

Tensorflow Graph의 모든 노드와 텐서에는 고유한 이름을 가지고 있습니다.

tf.constant(3, name='const')

위 코드를 수행하게 되면 이름이 'const'인 operation과 이름이 'const:0' 텐서를 만들게 됩니다.
그렇기에 python 변수에 결과를 않아도 우리는 tensor 또는 operation을 호출 할 수 있습니다.
아래 코드를 통해 확인해 보겠습니다.

tf.constant(3, name='const')

# tensorflow version 1.x
g = tf.get_default_graph()

# call 'const:0' tensor
g.get_tensor_by_name('const:0')

# call 'const' operation
g.get_operation_by_name('const')

위 코드를 보면
Graph는 노드와 텐서에 고유한 이름을 부여하고 그 이름으로 텐서와 노드를 관리하기 때문에 알면 굳이 파이썬 변수에 등록하지 않아도 된다는 점 입니다.

Eager Execution

반면 Eager Execution은 파이썬 변수를 통해 Tensor을 관리합니다.

a = tf.constant(3, name='const')

Computation Speed

계산 스피드는 Graph 가 Eager Execution 보다 빠릅니다.
eager execution 은 line-by-line 으로 한줄한줄 실행하지만
graph execution 은 compile 을 통해 효율적으로 그래프를 build 하고 수행하기 때문에 eager execution 보다 빠르게 수행 됩니다.

4층 짜리 Dense Layer 을 만든후 수행해 보면서 속도를 확인해봅니다.

Eager execution mode

# tensorflow 2.x eager Execution
import tensorflow as tf 
import numpy as np 
import time 
from tqdm import tqdm

# load MNIST Dataset 
train_data, test_data = tf.keras.datasets.mnist.load_data()
(train_xs, train_ys) = train_data
train_xs = train_xs.reshape([-1, 784])
train_xs = train_xs.astype(np.float32)

# Generate W, b
def generate_w_b(in_, out):
  w_init = tf.random.normal([in_, out])
  w = tf.Variable(w_init, dtype=tf.float32)
  b_init = tf.zeros(out)
  b = tf.Variable(b_init,dtype=tf.float32)
  return w, b

w1, b1 = generate_w_b(784, 128)
w2, b2 = generate_w_b(128, 128)
w3, b3 = generate_w_b(128, 128)
w4, b4 = generate_w_b(128, 10)

# Run Dense Layer , 100 times
s = time.time()
for i in tqdm(range(100)):
    layer = train_xs

    z1 = tf.matmul(layer, w1) + b1
    a1 = tf.nn.relu(z1)

    z2 = tf.matmul(a1, w2) + b2
    a2 = tf.nn.relu(z2)

    z3 = tf.matmul(a2, w3) + b3
    a3 = tf.nn.relu(z3)

    logits = tf.matmul(a3, w4) + b4

print('Consume time : {}'.format(time.time() - s))
# >>> 100%|██████████| 100/100 [00:31<00:00,  3.22it/s] Consume time : 31.025146961212158

Graph execution mode

연산이 수행되는 부분을 Graph 로 변환후 연산합니다.

# tensorflow 2.x Graph Execution
import tensorflow as tf 
import numpy as np 
import time 
from tqdm import tqdm

# load MNIST Dataset 
train_data, test_data = tf.keras.datasets.mnist.load_data()
(train_xs, train_ys) = train_data
train_xs = train_xs.reshape([-1, 784])
train_xs = train_xs.astype(np.float32)

# Generate W, b
def generate_w_b(in_, out):
    w_init = tf.random.normal([in_, out])
    w = tf.Variable(w_init, dtype=tf.float32)
    b_init = tf.zeros(out)
    b = tf.Variable(b_init,dtype=tf.float32)
    return w, b

w1, b1 = generate_w_b(784, 128)
w2, b2 = generate_w_b(128, 128)
w3, b3 = generate_w_b(128, 128)
w4, b4 = generate_w_b(128, 10)

# Run Dense Layer, 100 times
@tf.function
def graph_execution(layer):
    z1 = tf.matmul(layer, w1) + b1
    a1 = tf.nn.relu(z1)

    z2 = tf.matmul(a1, w2) + b2
    a2 = tf.nn.relu(z2)

    z3 = tf.matmul(a2, w3) + b3
    a3 = tf.nn.relu(z3)

    logits = tf.matmul(a3, w4) + b4

# execute Graph, 100 times 
s = time.time()
for i in tqdm(range(100)):
    graph_execution(train_xs)
print('Consume time : {}'.format(time.time() - s))
# >>> 100%|██████████| 100/100 [00:00<00:00, 847.78it/s] Consume time : 0.12074828147888184

속도가 Eager Execution mode 와 Graph Execution Mode 가 약 266배 정도 차이가 나는것을 확인할 수 있습니다.

Sum-up

Tensorflow 을 통해 연산(Computation)을 수행하는 방법은 크게 Eager execution, Graph execution 모드가 있습니다.
Eager execution 모드는 통해 기존에 사용했던 파이썬 변수 관리 방식을 사용할 수 있으며 Debug 모드를 사용 가능합니다.
하지만 Graph 모드보다 속도가 느립니다.
그렇기에 우리는 Eager execution 을 통해 먼저 돌아가는 코드를 만들고 이후
eager Execution 에서 Computation 부분을 Graph Execution 으로 바꾸는 코드 작업을 수행하게 됩니다.