딥러닝이 덧셈을 하는 방법, Attention Mechanism으로 살펴보기

필자가 지난번 seq2seq기반 덧셈 모형 빌드(with Gluon)을 Gluon으로 구축했으며, 잘 동작하는 모습을 보여줬다. 해당 코드를 정리하면서 딥러닝이 어떠한 방식으로 덧셈을 하는지 조금더 엿볼 수 있으면 어떨까 하는 생각이 들었다. 이 글을 보기 전에 이전 포스트를 먼저 읽어보길 권한다.

이 포스트에서 보여줄 두가지 부분은 어텐션 매커니즘(attention mechanism) 구현과 시각화 그리고 Gluon 모델의 학습/예측 퍼포먼스 향상을 할 수 있는 Hybridize 기능 테스트이다.

어텐션 매커니즘

먼저 어텐션 매커니즘이다.

사실상 seq2seq 기반의 딥러닝 interpretation 방법은 어텐션 매커니즘(attention mechanism)이 대표적이다. 그러나 이러한 효과뿐만아니라 원래 어텐션 방법이 사용된 동기는 seq2seq 모형의 sequence가 길어질 수록 과거 상태를 기억하지 못하는 단점이 존재해서 별도의 네트웍을 이용해 우리가 주목해야될 벡터가 무엇인지 강조해 주는데 목적이 있다. 하지만 최대 9문자를 기반으로 덧셈을 수행하는 모형에 어텐션까지 필요할 이유는 없으나, NMT(Neural Machine Translation)을 만들어 보기 전단계의 기술 튜토리얼이라 생각하겠다.

attention mechanism은 어떠한 특정의 알고리즘이 아니라 특정 정보를 뽑기위한 컨셉이다. 좀더 자세히 이야기 하면 디코더의 정보를 인코더의 정보로 어떻게 가공하느냐의 방식은 오픈된 영역이고 구현하기 나름이라는 것이다. 이러한 이유로 지금까지 공개적인 프레임웍에서 구현체가 등장하지 않은게 아닐까 하는 개인적인 생각을 해본다.

해당 매커니즘에 대한 설명은 이곳 블로그에서 잘 설명하고 있다. 사실 이 레벨 이상 개념을 설명하는건 어렵다고 생각한다. 하지만 별도로 필자는 구현체를 기준으로 설명을 좀더 자세히 해보도록 하겠다.

필자가 구현한 구현체의 얼개는 대체적으로 아래와 같다.

결국 위 그림에서 attend를 어떻게 구해주냐이며, 이 과정은 soft하게 진행된다. 이 말인즉, deocder의 매 시퀀스가 진행될때마다 다시 encoder sequence의 가중치를 달리한다는 것이다.
매 디코더 시퀀스가 진행되면서, 인코더 시퀀스에서 강조해야 될 부분을 디코더 입력값(Input)과 디코더의 히든 스테이트의 값(hidden)을 기반으로 계산(Concat, Dense)하고, 이를 인코드 시퀀스에 가중(X 연산)한뒤, 결과로 나온 값을 기반으로 다시 디코더 입력값에 적용(Concat, Dense)해 새로운 인코더의 입력(Output)으로 넣어주는 과정을 거친다.

결국 코드에서는 개별 Input에 대해서 인코더의 가중 정보를 추가해 새로운 Input을 만들어주는게 아래 apply_attention()함수에서 수행하는 과정이다.

Gluon Hybridize

두 번째 확인할 기술적인 부분은 Gluon Hybridize이다. Gluon에서 아주 간단한 코드 수정만으로 학습속도 및 예측속도를 상승시킬 수 있는 방식이다.

Gluon에서 Hybridize는 일종의 모형 컴파일 기능이다. PyTorch의 경우 Imperative 방식을 지원하고 이 덕분에 빠른 디버깅 및 구현이 가능한 장점이 있는데, Gluon에서도 일반적으로 Imperative방식으로 구현하게 하고 모형 구현이 다 된 이후 프로덕션에 올리기 위해 이 모형을 Symbolic 방식으로 변환시켜 올릴 수 있게 하는데, 이를 Hybridize라고 한다(Symbolic 방식의 대표적인 프레임웍은 TensorFlow이며, 메모리 최적화 및 속도가 빠른 장점이 있다). 필자의 경험상 평균 2배 이상의 학습/예측속도 성능향상이 보장되었다. 이를 위해 Gluon에서 gluon.HybridBlock클래스를 상속받아 hybrid_forward()함수를 재구현하게 한다.

hybrid_forward()함수에서 특이한 인자인 F가 있는데, 이 인자가 입력되는 데이터에 따라서 mx.sym기반 연산을 수행할지 mx.nd기반 연산을 수행할지 자동으로 선택되게 한다. Hybridize함수 호출 이후에는 내부적으로 모든 연산은 symbolic하게 구성이 되며 mx.nd array가 입력되더라도 symbol로 자동으로 변환되게 된다.

학습 속도 비교 테스트 결과는 아래에서 확인해 보도록 하겠다.

In [1]:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from mxnet import nd as  F
import mxnet as mx
from  mxnet import gluon
from mxnet.gluon import nn, rnn
import mxnet.autograd as autograd
from mxnet import nd as F
import seaborn as sns 
sns.set_style("whitegrid")
%matplotlib inline

아래는 학습 데이터 생성 코드이다. 이전 포스트에 비해서 달라진 부분은 input_digits, output_digits길이를 같게 해준 부분이다. 이 부분은 모형 해석을 위해 맞춰줬다.

In [18]:
def n(digits=3):
    number = ''
    for i in range(np.random.randint(1, digits + 1)):
        number += np.random.choice(list('0123456789'))
    return int(number)


def padding(chars, maxlen):
    return chars + ' ' * (maxlen - len(chars))


N = 50000
N_train = int(N * 0.9)
N_validation = N - N_train

digits = 3  # 최대 자릿수
input_digits = digits * 2 + 3  # 예: 123+456
output_digits = digits * 2 + 3 # 500+500 = 1000 이상이면 4자리가 된다

added = set()
questions = []
answers = []
answers_y = []

while len(questions) < N:
    a, b = n(), n()  # 두 개의 수를 적당히 생성한다

    pair = tuple(sorted((a, b)))
    if pair in added:
        continue

    question = 'S{}+{}E'.format(a, b)
    question = padding(question, input_digits)
    answer = 'S' + str(a + b) + 'E'
    answer = padding(answer, output_digits)
    answer_y = str(a + b) + 'E'
    answer_y = padding(answer_y, output_digits)
    

    added.add(pair)
    questions.append(question)
    answers.append(answer)
    answers_y.append(answer_y)

chars = '0123456789+SE '
char_indices = dict((c, i) for i, c in enumerate(chars))
indices_char = dict((i, c) for i, c in enumerate(chars))

X = np.zeros((len(questions), input_digits, len(chars)), dtype=np.integer)
Y = np.zeros((len(questions), digits * 2 + 3, len(chars)), dtype=np.integer)
Z = np.zeros((len(questions), digits * 2 + 3, len(chars)), dtype=np.integer)

for i in range(N):
    for t, char in enumerate(questions[i]):
        X[i, t, char_indices[char]] = 1
    for t, char in enumerate(answers[i]):
        Y[i, t, char_indices[char]] = 1
    for t, char in enumerate(answers_y[i]):
        Z[i, t, char_indices[char]] = 1
    
X_train, X_validation, Y_train, Y_validation, Z_train, Z_validation = \
    train_test_split(X, Y, Z, train_size=N_train)
/home/gogamza/python_3.6.4/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2026: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.
  FutureWarning)

예시 테스트 데이터를 생성하는 함수 (이전과 같다.)

In [3]:
def gen_n_test(N):
    q = []
    y = []
    for i in range(N):
        a, b = n(), n() 
        question = '{}+{}'.format(a, b)
        answer_y = str(a + b)
        q.append(question)
        y.append(answer_y)
    return(q,y)

적중 유무를 색으로 표시하기 위해…

In [4]:
class colors:
    ok = '\033[92m'
    fail = '\033[91m'
    close = '\033[0m'

gluon.HybridBlock을 상속받아 HybridBlock으로 구성했다. 참고로 array[:,1,:] 방식의 슬라이싱 형태의 연산을 mx.nd.*계열 함수 연산으로 모두 바꿔줘야 된다.

In [5]:
class calculator(gluon.HybridBlock):
    
    def __init__(self, n_hidden, vacab_size, max_seq_length=9, attention=False ,**kwargs):
        super(calculator,self).__init__(**kwargs)
        #입력 시퀀스 길이
        self.in_seq_len = max_seq_length
        #출력 시퀀스 길이 
        self.out_seq_len = max_seq_length
        # LSTM의 hidden 개수 
        self.n_hidden = n_hidden
        #고유문자개수 
        self.vacab_size = vacab_size
        #max_seq_length
        self.max_seq_length = max_seq_length
        
        self.attention = attention
        with self.name_scope():
            self.encoder = rnn.LSTMCell(hidden_size=n_hidden)
            self.decoder = rnn.LSTMCell(hidden_size=n_hidden)
            self.batchnorm = nn.BatchNorm(axis=2)
            #flatten을 false로 할 경우 마지막 차원에 fully connected가 적용된다. 
            self.dense = nn.Dense(self.vacab_size,flatten=False)
            if self.attention:
                self.attdense = nn.Dense(self.max_seq_length, flatten=False)
                self.attn_combine = nn.Dense( self.vacab_size, flatten=False)
            
    def hybrid_forward(self,F, inputs, outputs):
        """
        학습 코드 
        """
        #encoder LSTM
        enout, (next_h, next_c) = self.encoder.unroll(inputs=inputs, length=self.in_seq_len, merge_outputs=True)        
        #decoder LSTM with attention
        for i in range(self.out_seq_len):
            #out_seq_len 길이만큼 LSTMcell을 unroll하면서 출력값을 적재한다. 
            p_outputs = F.slice_axis(outputs, axis=1, begin=i, end=i+1)
            p_outputs = F.reshape(p_outputs, (-1, self.vacab_size))
            # p_outputs = outputs[:,i,:]
            # 위와 같이 진행한 이유는 hybridize를 위함 

            if self.attention:
                p_outputs, _ = self.apply_attention(F=F, inputs=p_outputs, hidden=next_h, encoder_outputs=enout)
            deout, (next_h, next_c) = self.decoder(p_outputs, [next_h, next_c], )
            if i == 0:
                deouts = deout
            else:
                deouts = F.concat(deouts, deout, dim=1)
        #2dim -> 3dim 으로 reshape 
        deouts_orig = F.reshape(deouts, (-1, self.out_seq_len, self.n_hidden))
        
        deouts = self.batchnorm(deouts_orig)
        deouts_fc = self.dense(deouts)
        return(deouts_fc)
    
    def apply_attention(self, F, inputs, hidden, encoder_outputs):
        #inputs : decoder input의미
        concated = F.concat(inputs, hidden, dim=1)
        #(,max_seq_length) : max_seq_length 개별 시퀀스의 중요도  
        attn_weights = F.softmax(self.attdense(concated), axis=1)
        #(N,max_seq_length) x (N,max_seq_length,n_hidden) = (N, max_seq_length, n_hidden)
        #attn_weigths 가중치를 인코더 출력값에 곱해줌
        w_encoder_outputs = F.broadcast_mul(encoder_outputs, attn_weights.expand_dims(2))
        #(N, vocab_size * max_seq_length), (N, max_seq_length * n_hidden) = (N, ...)
        output = F.concat(inputs.flatten(), w_encoder_outputs.flatten(), dim=1)
        #(N, vocab_size)
        output = self.attn_combine(output)
        #attention weight은 시각화를 위해 뽑아둔다. 
        return(output, attn_weights)
    
    def calulation(self, input_str, char_indices, indices_char, input_digits=9, lchars=14, ctx=mx.gpu(0)):
        """
        inference 코드 
        """
        #앞뒤에 S,E 코드 추가 
        input_str = 'S' + input_str + 'E'
        #string to one-hot coding 
        X = F.zeros((1, input_digits, lchars), ctx=ctx)
        for t, char in enumerate(input_str):
            X[0, t, char_indices[char]] = 1
        #디코더의 초기 입력값으로 넣을 'S'를 one-hot coding한다. 
        Y_init = F.zeros((1, lchars), ctx=ctx)
        Y_init[0,char_indices['S']] = 1
        #인코더 출력값을 도출한다. 
        enout, (next_h, next_c) = self.encoder.unroll(inputs=X, length=self.in_seq_len, merge_outputs=True)
        deout = Y_init
        #출력 시퀀스 길이만큼 순회 
        for i in range(self.out_seq_len):
            if self.attention:
                deout, att_weight = self.apply_attention(F=F, inputs=deout, hidden=next_h, encoder_outputs=enout)
                if i == 0:
                    att_weights = att_weight
                else:
                    att_weights = F.concat(att_weights,att_weight,dim=0)
            deout, (next_h, next_c) = self.decoder(deout, [next_h, next_c])
            #batchnorm을 적용하기 위해 차원 증가/원복 
            deout = F.expand_dims(deout,axis=1)
            deout = self.batchnorm(deout)
            #reduce dim
            deout = deout[:,0,:]
            #'S'의 다음 시퀀스 출력값도출 
            deout_sm = self.dense(deout)
            deout = F.one_hot(F.argmax(F.softmax(deout_sm, axis=1), axis=1), depth=self.vacab_size)
            gen_char  = indices_char[F.argmax(deout_sm, axis=1).asnumpy()[0].astype('int')]
            if gen_char == ' ' or gen_char == 'E':
                break
            else: 
                if i == 0:
                    ret_seq = gen_char
                else:
                    ret_seq += gen_char
        return(ret_seq, att_weights)

                

data iterator 생성

In [6]:
tr_set = gluon.data.ArrayDataset(X_train, Y_train, Z_train)
tr_data_iterator = gluon.data.DataLoader(tr_set, batch_size=256, shuffle=True)

te_set =gluon.data.ArrayDataset(X_validation, Y_validation, Z_validation)
te_data_iterator = gluon.data.DataLoader(te_set, batch_size=256, shuffle=True)
In [35]:
ctx = mx.gpu()

def model_init():
    #모형 인스턴스 생성 및 트래이너, loss 정의 
    model = calculator(300, 14, attention=True)
    model.collect_params().initialize(mx.init.Xavier(), ctx=ctx)

    trainer = gluon.Trainer(model.collect_params(), 'rmsprop') 
    loss = gluon.loss.SoftmaxCrossEntropyLoss(axis = 2, sparse_label=False)
    return(model, loss, trainer)
In [27]:
model.hybridize()
print(model)
calculator(
  (encoder): LSTMCell(14 -> 1200)
  (decoder): LSTMCell(14 -> 1200)
  (batchnorm): BatchNorm(axis=2, eps=1e-05, momentum=0.9, fix_gamma=False, in_channels=300)
  (dense): Dense(300 -> 14, linear)
  (attdense): Dense(314 -> 9, linear)
  (attn_combine): Dense(2714 -> 14, linear)
)
In [28]:
def calculate_loss(model, data_iter, loss_obj, ctx=ctx):
    test_loss = []
    for i, (x_data, y_data, z_data) in enumerate(data_iter):
        x_data = x_data.as_in_context(ctx).astype('float32')
        y_data = y_data.as_in_context(ctx).astype('float32')
        z_data = z_data.as_in_context(ctx).astype('float32')
        with autograd.predict_mode():
            z_output = model(x_data, y_data)
            loss_te = loss_obj(z_output, z_data)
        curr_loss = mx.nd.mean(loss_te).asscalar()
        test_loss.append(curr_loss)
    return(np.mean(test_loss))
In [23]:
def train(epochs, tr_data_iterator, model, loss, trainer):
    ### 학습 코드 
    tot_test_loss = []
    tot_train_loss = []
    for e in range(epochs):
        train_loss = []
        for i, (x_data, y_data, z_data) in enumerate(tr_data_iterator):
            x_data = x_data.as_in_context(ctx).astype('float32')
            y_data = y_data.as_in_context(ctx).astype('float32')
            z_data = z_data.as_in_context(ctx).astype('float32')
            with autograd.record():
                z_output = model(x_data, y_data)
                loss_ = loss(z_output, z_data)
            loss_.backward()
            trainer.step(x_data.shape[0])
            curr_loss = mx.nd.mean(loss_).asscalar()
            train_loss.append(curr_loss)
        if e % 10 == 0:
            # 매 10 에폭마다 예제 테스트 결과 출력 
            q, y = gen_n_test(10)
            for i in range(10):
                with autograd.predict_mode():
                    p, att_weight = model.calulation(q[i], char_indices, indices_char)
                    iscorr = 1 if p == y[i] else 0
                    if iscorr == 1:
                        print(colors.ok + '☑' + colors.close, end=' ')
                    else:
                        print(colors.fail + '☒' + colors.close, end=' ')
                    print("{} = {}({}) 1/0 {}".format(q[i], p, y[i], str(iscorr) ))
        #caculate test loss
        test_loss = calculate_loss(model, te_data_iterator, loss_obj = loss, ctx=ctx) 

        print("Epoch %s. Train Loss: %s, Test Loss : %s" % (e, np.mean(train_loss), test_loss))    
        tot_test_loss.append(test_loss)
        tot_train_loss.append(np.mean(train_loss))

Hybridize 기능을 테스트해보겠다. hybridize() 함수 호출 전까지 모형은 PyTorch와 같은 Imperative 방식이다.

In [24]:
%%time
epochs = 10

model, loss, trainer = model_init()
#model.hybridize()
train(epochs, tr_data_iterator, model, loss, trainer)
 41+14 = 52(55) 1/0 0
 592+31 = 123(623) 1/0 0
 6+8 = 133(14) 1/0 0
 5+3 = 53(8) 1/0 0
 95+4 = 144(99) 1/0 0
 203+432 = 1103(635) 1/0 0
 22+8 = 23(30) 1/0 0
 23+4 = 53(27) 1/0 0
 37+21 = 23(58) 1/0 0
 353+56 = 533(409) 1/0 0
Epoch 0. Train Loss: 0.824254, Test Loss : 0.761439
Epoch 1. Train Loss: 0.754624, Test Loss : 0.746346
Epoch 2. Train Loss: 0.735081, Test Loss : 0.7196
Epoch 3. Train Loss: 0.709774, Test Loss : 0.702328
Epoch 4. Train Loss: 0.664592, Test Loss : 0.624134
Epoch 5. Train Loss: 0.596842, Test Loss : 0.566876
Epoch 6. Train Loss: 0.532285, Test Loss : 0.503133
Epoch 7. Train Loss: 0.471627, Test Loss : 0.432467
Epoch 8. Train Loss: 0.397328, Test Loss : 0.386968
Epoch 9. Train Loss: 0.300068, Test Loss : 0.26212
CPU times: user 1min 10s, sys: 5.97 s, total: 1min 16s
Wall time: 1min 16s

10회 에폭을 도는데 약 76초 소요되었다.

아래는 hybridize()호출 이후의 성능이다.

In [38]:
%%time
epochs = 10

model, loss, trainer = model_init()
model.hybridize()
train(epochs, tr_data_iterator, model, loss, trainer)
 7+516 = 137(523) 1/0 0
 8+164 = 1006(172) 1/0 0
 7+1 = 87(8) 1/0 0
 1+576 = 137(577) 1/0 0
 69+654 = 103(723) 1/0 0
 3+686 = 1006(689) 1/0 0
 275+6 = 837(281) 1/0 0
 215+873 = 1006(1088) 1/0 0
 0+13 = 43(13) 1/0 0
 31+54 = 45(85) 1/0 0
Epoch 0. Train Loss: 0.823232, Test Loss : 0.76641
Epoch 1. Train Loss: 0.754593, Test Loss : 0.73315
Epoch 2. Train Loss: 0.732862, Test Loss : 0.723394
Epoch 3. Train Loss: 0.707921, Test Loss : 0.707123
Epoch 4. Train Loss: 0.656242, Test Loss : 0.619234
Epoch 5. Train Loss: 0.587669, Test Loss : 0.551538
Epoch 6. Train Loss: 0.522011, Test Loss : 0.49857
Epoch 7. Train Loss: 0.458266, Test Loss : 0.425738
Epoch 8. Train Loss: 0.380518, Test Loss : 0.331749
Epoch 9. Train Loss: 0.283062, Test Loss : 0.237838
CPU times: user 41.7 s, sys: 5.9 s, total: 47.6 s
Wall time: 47.5 s

47초 소요되어 1.6배 학습속도 향상이 있었다는 것을 알 수 있다. GPU 메모리 사용 효율측면에서는 별도 확인이 필요하다.

그럼 120에폭정도 더 수행해 모형을 충분히 학습 시킨 후 입력 수식에 대한 어텐션 가중치를 시각화 해보도록 하자!

In [74]:
%%time
epochs=120

model, loss, trainer = model_init()

model.hybridize()

train(epochs, tr_data_iterator, model, loss, trainer)
 3+81 = 148(84) 1/0 0
 977+9 = 1005(986) 1/0 0
 7+24 = 148(31) 1/0 0
 656+9 = 664(665) 1/0 0
 40+6 = 64(46) 1/0 0
 68+24 = 128(92) 1/0 0
 1+3 = 148(4) 1/0 0
 133+5 = 348(138) 1/0 0
 86+7 = 148(93) 1/0 0
 11+3 = 14(14) 1/0 1
Epoch 0. Train Loss: 0.825168, Test Loss : 0.767453
Epoch 1. Train Loss: 0.756016, Test Loss : 0.739215
Epoch 2. Train Loss: 0.734977, Test Loss : 0.715725
Epoch 3. Train Loss: 0.71032, Test Loss : 0.690968
Epoch 4. Train Loss: 0.667081, Test Loss : 0.626816
Epoch 5. Train Loss: 0.598926, Test Loss : 0.568374
Epoch 6. Train Loss: 0.536676, Test Loss : 0.518665
Epoch 7. Train Loss: 0.480421, Test Loss : 0.470468
Epoch 8. Train Loss: 0.408548, Test Loss : 0.360566
Epoch 9. Train Loss: 0.319136, Test Loss : 0.26157
 7+86 = 142(93) 1/0 0
 4+7 = 91(11) 1/0 0
 49+1 = 52(50) 1/0 0
 8+4 = 121(12) 1/0 0
 0+5 = 66(5) 1/0 0
 87+47 = 125(134) 1/0 0
 68+8 = 16(76) 1/0 0
 8+173 = 180(181) 1/0 0
 6+7 = 11(13) 1/0 0
 1+97 = 98(98) 1/0 1
Epoch 10. Train Loss: 0.238364, Test Loss : 0.202284
Epoch 11. Train Loss: 0.17943, Test Loss : 0.16156
Epoch 12. Train Loss: 0.13782, Test Loss : 0.126919
Epoch 13. Train Loss: 0.107754, Test Loss : 0.0889748
Epoch 14. Train Loss: 0.0870873, Test Loss : 0.103543
Epoch 15. Train Loss: 0.0710014, Test Loss : 0.0490341
Epoch 16. Train Loss: 0.0582392, Test Loss : 0.0400203
Epoch 17. Train Loss: 0.0513369, Test Loss : 0.079818
Epoch 18. Train Loss: 0.043383, Test Loss : 0.0283036
Epoch 19. Train Loss: 0.0394423, Test Loss : 0.0268908
 26+709 = 735(735) 1/0 1
 170+9 = 179(179) 1/0 1
 54+37 = 102(91) 1/0 0
 657+848 = 1506(1505) 1/0 0
 908+9 = 917(917) 1/0 1
 276+8 = 284(284) 1/0 1
 908+9 = 917(917) 1/0 1
 19+86 = 106(105) 1/0 0
 625+87 = 712(712) 1/0 1
 47+819 = 866(866) 1/0 1
Epoch 20. Train Loss: 0.0328585, Test Loss : 0.144795
Epoch 21. Train Loss: 0.0316994, Test Loss : 0.018304
Epoch 22. Train Loss: 0.025674, Test Loss : 0.022579
Epoch 23. Train Loss: 0.0247622, Test Loss : 0.0605186
Epoch 24. Train Loss: 0.0246277, Test Loss : 0.0153878
Epoch 25. Train Loss: 0.0182371, Test Loss : 0.0132016
Epoch 26. Train Loss: 0.0187628, Test Loss : 0.0211464
Epoch 27. Train Loss: 0.0164157, Test Loss : 0.0227994
Epoch 28. Train Loss: 0.0161711, Test Loss : 0.0143485
Epoch 29. Train Loss: 0.015138, Test Loss : 0.0146324
 9+90 = 198(99) 1/0 0
 2+9 = 110(11) 1/0 0
 5+70 = 154(75) 1/0 0
 8+76 = 84(84) 1/0 1
 1+361 = 362(362) 1/0 1
 78+133 = 211(211) 1/0 1
 6+4 = 01(10) 1/0 0
 7+6 = 13(13) 1/0 1
 41+271 = 312(312) 1/0 1
 6+5 = 11(11) 1/0 1
Epoch 30. Train Loss: 0.0126626, Test Loss : 0.00964922
Epoch 31. Train Loss: 0.0137871, Test Loss : 0.0153549
Epoch 32. Train Loss: 0.0115217, Test Loss : 0.00980532
Epoch 33. Train Loss: 0.0105796, Test Loss : 0.0240031
Epoch 34. Train Loss: 0.0106281, Test Loss : 0.0082361
Epoch 35. Train Loss: 0.011613, Test Loss : 0.00777388
Epoch 36. Train Loss: 0.00835043, Test Loss : 0.0241034
Epoch 37. Train Loss: 0.0115577, Test Loss : 0.00717236
Epoch 38. Train Loss: 0.00739578, Test Loss : 0.0142979
Epoch 39. Train Loss: 0.00882682, Test Loss : 0.0429244
 27+6 = 33(33) 1/0 1
 3+336 = 339(339) 1/0 1
 24+0 = 24(24) 1/0 1
 343+15 = 358(358) 1/0 1
 1+36 = 37(37) 1/0 1
 381+372 = 753(753) 1/0 1
 1+6 = 7(7) 1/0 1
 33+38 = 71(71) 1/0 1
 7+40 = 17(47) 1/0 0
 721+5 = 726(726) 1/0 1
Epoch 40. Train Loss: 0.00739518, Test Loss : 0.00945118
Epoch 41. Train Loss: 0.00699975, Test Loss : 0.00649165
Epoch 42. Train Loss: 0.00697939, Test Loss : 0.0370892
Epoch 43. Train Loss: 0.00649944, Test Loss : 0.00670839
Epoch 44. Train Loss: 0.00505114, Test Loss : 0.00609406
Epoch 45. Train Loss: 0.00627439, Test Loss : 0.00577808
Epoch 46. Train Loss: 0.00559468, Test Loss : 0.00468896
Epoch 47. Train Loss: 0.00645781, Test Loss : 0.00447931
Epoch 48. Train Loss: 0.00548245, Test Loss : 0.00390221
Epoch 49. Train Loss: 0.0037191, Test Loss : 0.00839095
 13+69 = 92(82) 1/0 0
 657+9 = 766(666) 1/0 0
 13+6 = 19(19) 1/0 1
 6+28 = 34(34) 1/0 1
 93+544 = 637(637) 1/0 1
 1+27 = 28(28) 1/0 1
 76+9 = 16(85) 1/0 0
 1+322 = 323(323) 1/0 1
 0+324 = 324(324) 1/0 1
 24+879 = 903(903) 1/0 1
Epoch 50. Train Loss: 0.00546992, Test Loss : 0.00484758
Epoch 51. Train Loss: 0.00571622, Test Loss : 0.00352642
Epoch 52. Train Loss: 0.00355334, Test Loss : 0.0834598
Epoch 53. Train Loss: 0.00415901, Test Loss : 0.01031
Epoch 54. Train Loss: 0.00357408, Test Loss : 0.00943809
Epoch 55. Train Loss: 0.0043509, Test Loss : 0.0114941
Epoch 56. Train Loss: 0.00328733, Test Loss : 0.016379
Epoch 57. Train Loss: 0.00430432, Test Loss : 0.00491822
Epoch 58. Train Loss: 0.00420605, Test Loss : 0.0168014
Epoch 59. Train Loss: 0.00270261, Test Loss : 0.00543849
 27+617 = 644(644) 1/0 1
 616+865 = 1481(1481) 1/0 1
 2+9 = 11(11) 1/0 1
 7+448 = 455(455) 1/0 1
 19+445 = 464(464) 1/0 1
 28+24 = 52(52) 1/0 1
 1+54 = 55(55) 1/0 1
 7+86 = 93(93) 1/0 1
 66+8 = 15(74) 1/0 0
 40+99 = 139(139) 1/0 1
Epoch 60. Train Loss: 0.00298974, Test Loss : 0.0112894
Epoch 61. Train Loss: 0.0026023, Test Loss : 0.0172168
Epoch 62. Train Loss: 0.00268022, Test Loss : 0.012286
Epoch 63. Train Loss: 0.0018094, Test Loss : 0.00490898
Epoch 64. Train Loss: 0.00387757, Test Loss : 0.00347905
Epoch 65. Train Loss: 0.00380811, Test Loss : 0.00607187
Epoch 66. Train Loss: 0.00383814, Test Loss : 0.00379982
Epoch 67. Train Loss: 0.00325786, Test Loss : 0.00494786
Epoch 68. Train Loss: 0.00181743, Test Loss : 0.00611921
Epoch 69. Train Loss: 0.00192108, Test Loss : 0.00291146
 2+4 = 6(6) 1/0 1
 90+697 = 787(787) 1/0 1
 5+45 = 50(50) 1/0 1
 706+869 = 1575(1575) 1/0 1
 55+975 = 1030(1030) 1/0 1
 710+68 = 778(778) 1/0 1
 76+76 = 152(152) 1/0 1
 4+716 = 720(720) 1/0 1
 436+6 = 842(442) 1/0 0
 4+64 = 79(68) 1/0 0
Epoch 70. Train Loss: 0.00136225, Test Loss : 0.00592418
Epoch 71. Train Loss: 0.00181755, Test Loss : 0.0062309
Epoch 72. Train Loss: 0.00243407, Test Loss : 0.00442789
Epoch 73. Train Loss: 0.00260408, Test Loss : 0.00350842
Epoch 74. Train Loss: 0.00237293, Test Loss : 0.00341684
Epoch 75. Train Loss: 0.00150905, Test Loss : 0.00883918
Epoch 76. Train Loss: 0.00320077, Test Loss : 0.00698871
Epoch 77. Train Loss: 0.00209205, Test Loss : 0.00182626
Epoch 78. Train Loss: 0.00182465, Test Loss : 0.00186032
Epoch 79. Train Loss: 0.000723624, Test Loss : 0.00199059
 3+52 = 55(55) 1/0 1
 533+15 = 548(548) 1/0 1
 96+1 = 97(97) 1/0 1
 0+6 = 76(6) 1/0 0
 2+4 = 6(6) 1/0 1
 7+705 = 712(712) 1/0 1
 32+2 = 4(34) 1/0 0
 724+94 = 818(818) 1/0 1
 88+41 = 129(129) 1/0 1
 14+938 = 952(952) 1/0 1
Epoch 80. Train Loss: 0.00167028, Test Loss : 0.00622146
Epoch 81. Train Loss: 0.0016086, Test Loss : 0.00269476
Epoch 82. Train Loss: 0.00202565, Test Loss : 0.00734851
Epoch 83. Train Loss: 0.00151956, Test Loss : 0.0033036
Epoch 84. Train Loss: 0.00216222, Test Loss : 0.00322925
Epoch 85. Train Loss: 0.00129533, Test Loss : 0.00521608
Epoch 86. Train Loss: 0.00194144, Test Loss : 0.00308441
Epoch 87. Train Loss: 0.00213242, Test Loss : 0.00444548
Epoch 88. Train Loss: 0.00143301, Test Loss : 0.00290399
Epoch 89. Train Loss: 0.00155274, Test Loss : 0.00262825
 7+6 = 13(13) 1/0 1
 22+45 = 67(67) 1/0 1
 110+1 = 111(111) 1/0 1
 28+42 = 70(70) 1/0 1
 830+328 = 1158(1158) 1/0 1
 596+7 = 703(603) 1/0 0
 50+65 = 115(115) 1/0 1
 959+203 = 1162(1162) 1/0 1
 673+288 = 961(961) 1/0 1
 94+35 = 139(129) 1/0 0
Epoch 90. Train Loss: 0.00109719, Test Loss : 0.00269497
Epoch 91. Train Loss: 0.00139488, Test Loss : 0.00137743
Epoch 92. Train Loss: 0.000944466, Test Loss : 0.0062532
Epoch 93. Train Loss: 0.00143602, Test Loss : 0.00549752
Epoch 94. Train Loss: 0.000966025, Test Loss : 0.00189725
Epoch 95. Train Loss: 0.00184653, Test Loss : 0.00226197
Epoch 96. Train Loss: 0.00145132, Test Loss : 0.00311102
Epoch 97. Train Loss: 0.00169186, Test Loss : 0.0019748
Epoch 98. Train Loss: 0.00205613, Test Loss : 0.00283333
Epoch 99. Train Loss: 0.00135589, Test Loss : 0.00460187
 622+870 = 1492(1492) 1/0 1
 4+900 = 904(904) 1/0 1
 5+6 = 11(11) 1/0 1
 7+96 = 103(103) 1/0 1
 6+72 = 79(78) 1/0 0
 21+5 = 46(26) 1/0 0
 12+45 = 67(57) 1/0 0
 36+433 = 469(469) 1/0 1
 7+7 = 14(14) 1/0 1
 5+98 = 103(103) 1/0 1
Epoch 100. Train Loss: 0.000901395, Test Loss : 0.0020496
Epoch 101. Train Loss: 0.00060482, Test Loss : 0.00142988
Epoch 102. Train Loss: 0.001804, Test Loss : 0.00403753
Epoch 103. Train Loss: 0.000682739, Test Loss : 0.00222608
Epoch 104. Train Loss: 0.000706889, Test Loss : 0.00178406
Epoch 105. Train Loss: 0.000696317, Test Loss : 0.00319806
Epoch 106. Train Loss: 0.00123298, Test Loss : 0.00221916
Epoch 107. Train Loss: 0.00174892, Test Loss : 0.00231955
Epoch 108. Train Loss: 0.00105368, Test Loss : 0.00169426
Epoch 109. Train Loss: 0.000509891, Test Loss : 0.00143389
 54+72 = 126(126) 1/0 1
 6+512 = 518(518) 1/0 1
 81+543 = 624(624) 1/0 1
 70+35 = 105(105) 1/0 1
 1+1 = 1(2) 1/0 0
 497+502 = 999(999) 1/0 1
 26+11 = 37(37) 1/0 1
 0+401 = 401(401) 1/0 1
 24+4 = 39(28) 1/0 0
 32+960 = 992(992) 1/0 1
Epoch 110. Train Loss: 0.000900174, Test Loss : 0.00142159
Epoch 111. Train Loss: 0.000651126, Test Loss : 0.00130391
Epoch 112. Train Loss: 0.000686943, Test Loss : 0.00173441
Epoch 113. Train Loss: 3.17661e-05, Test Loss : 0.00116709
Epoch 114. Train Loss: 0.000172649, Test Loss : 0.00173078
Epoch 115. Train Loss: 0.000502408, Test Loss : 0.00674069
Epoch 116. Train Loss: 0.00102207, Test Loss : 0.00365347
Epoch 117. Train Loss: 0.00133691, Test Loss : 0.00596724
Epoch 118. Train Loss: 0.00180888, Test Loss : 0.00320445
Epoch 119. Train Loss: 0.000937606, Test Loss : 0.00228651
 78+619 = 697(697) 1/0 1
 8+66 = 74(74) 1/0 1
 64+169 = 233(233) 1/0 1
 9+537 = 546(546) 1/0 1
 24+54 = 78(78) 1/0 1
 40+27 = 67(67) 1/0 1
 33+66 = 99(99) 1/0 1
 59+1 = 60(60) 1/0 1
 894+61 = 955(955) 1/0 1
 43+117 = 160(160) 1/0 1
Epoch 120. Train Loss: 0.000394131, Test Loss : 0.00273019
Epoch 121. Train Loss: 0.00137362, Test Loss : 0.00342603
Epoch 122. Train Loss: 0.00043142, Test Loss : 0.00290573
Epoch 123. Train Loss: 0.0011634, Test Loss : 0.00511772
Epoch 124. Train Loss: 0.00148208, Test Loss : 0.00206283
Epoch 125. Train Loss: 0.00133586, Test Loss : 0.00175459
Epoch 126. Train Loss: 0.0013493, Test Loss : 0.00116216
Epoch 127. Train Loss: 2.40396e-05, Test Loss : 0.00101399
Epoch 128. Train Loss: 1.31414e-05, Test Loss : 0.000794569
Epoch 129. Train Loss: 1.00081e-05, Test Loss : 0.000828097
 80+5 = 85(85) 1/0 1
 290+4 = 294(294) 1/0 1
 98+93 = 191(191) 1/0 1
 4+566 = 670(570) 1/0 0
 24+3 = 38(27) 1/0 0
 0+37 = 37(37) 1/0 1
 94+65 = 159(159) 1/0 1
 19+808 = 827(827) 1/0 1
 41+156 = 197(197) 1/0 1
 7+1 = 9(8) 1/0 0
Epoch 130. Train Loss: 8.69274e-06, Test Loss : 0.000794666
Epoch 131. Train Loss: 7.84394e-06, Test Loss : 0.000795893
Epoch 132. Train Loss: 7.25169e-06, Test Loss : 0.000766832
Epoch 133. Train Loss: 6.75748e-06, Test Loss : 0.000763409
Epoch 134. Train Loss: 6.3358e-06, Test Loss : 0.000759157
Epoch 135. Train Loss: 5.90163e-06, Test Loss : 0.000797004
Epoch 136. Train Loss: 5.5919e-06, Test Loss : 0.000777036
Epoch 137. Train Loss: 5.43287e-06, Test Loss : 0.000747087
Epoch 138. Train Loss: 5.25996e-06, Test Loss : 0.000790735
Epoch 139. Train Loss: 4.99143e-06, Test Loss : 0.000743235
 58+36 = 93(94) 1/0 0
 7+23 = 30(30) 1/0 1
 7+395 = 402(402) 1/0 1
 25+9 = 33(34) 1/0 0
 96+4 = 101(100) 1/0 0
 62+4 = 7(66) 1/0 0
 5+419 = 424(424) 1/0 1
 310+6 = 316(316) 1/0 1
 2+5 = 7(7) 1/0 1
 8+381 = 389(389) 1/0 1
Epoch 140. Train Loss: 4.90512e-06, Test Loss : 0.000739666
Epoch 141. Train Loss: 4.60695e-06, Test Loss : 0.000783125
Epoch 142. Train Loss: 4.53189e-06, Test Loss : 0.000721762
Epoch 143. Train Loss: 4.45555e-06, Test Loss : 0.000759457
Epoch 144. Train Loss: 4.27308e-06, Test Loss : 0.000735894
Epoch 145. Train Loss: 4.10945e-06, Test Loss : 0.000732467
Epoch 146. Train Loss: 3.95082e-06, Test Loss : 0.000741803
Epoch 147. Train Loss: 3.91119e-06, Test Loss : 0.000746307
Epoch 148. Train Loss: 3.80216e-06, Test Loss : 0.000744603
Epoch 149. Train Loss: 3.70733e-06, Test Loss : 0.000736042
CPU times: user 10min 21s, sys: 1min 27s, total: 11min 48s
Wall time: 11min 48s
In [75]:
in_sent = "900+900"
p, att_weight = model.calulation(in_sent, char_indices, indices_char)
p
Out[75]:
'1800'
In [76]:
ax = sns.heatmap(att_weight.asnumpy()[1:,1:-1][:len(p), :len(in_sent)], 
                 xticklabels=list(in_sent), 
                 yticklabels= list(p), cmap='bone')
ax.xaxis.tick_top()
ax.tick_params(axis='y', rotation='auto')

위에서 보면 1800의 첫번째 자리(1)를 계산하는데, 개별 숫자의 첫번째 자리의 숫자들이(9,9) 영향을 준것을 확인할 수 있다. 이 이외의 패턴은 어텐션으로는 명확하게 원리를 파악하기 어렵다는 것을 알 수 있다(굳이 해석하자면 십의자리 0의 계산 원리정도?).


어텐션은 seq2seq가 아니더라도 대부분의 네트웍에 활용 가능한 개념이다. 게다가 더불어 성능 향상 측면에서도 긍정적 효과가 있다고 알려져 있어서 그냥 묻지마 활용을 하는 추세이다. 무엇보다 필자가 개인적으로 상당히 좋은 점으로 꼽는 부분은 예측시각화 측면이다.

정말 이젠 영한 기계번역 모델을 만들어볼 때가 된것 같다. 아마도 위 모듈에서 임베딩 정도만 추가하면 기초적인 기계번역 모형을 구축할 수 있을 것으로 보인다.

 

reference : http://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html

CC BY-NC 4.0 딥러닝이 덧셈을 하는 방법, Attention Mechanism으로 살펴보기 by from __future__ import dream is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.