reniew's blog

ALBERT: A Lite BERT For Self-Supervised Learning of Language Representations

2020-03-10T07:41:15+00:00

오늘은 2019년 google research에서 나온 논문인 ALBERT: A Lite BERT For Self-Supervised Learning of Language Representations에 대해서 알아보도록 한다. 기존의 다양한 BERT의 후속 논문들이 모델 사이즈를 늘리며 성능을 올리던 것을 지적하며, ALBERT는 GPU memory를 효율적으로 사용하면서 모델 성능을 향상시킨 모델이다. 2020년 2월 현재 SQuAD 2.0 Leaderboard를 보면 1등부터 8등까지 랭크하고 있는 모델들이 모두 ALBERT를 활용한 모델이다.

이렇게 BERT의 GPU-utilize를 효율적으로 개선했음에도 불구하고 향상된 성능을 보이는 ALBERT에 대해서 알아보도록 하자.

Introduction

Fully network pre-training(BERT, GPT, ULMFiT) 방법들은 계속해서 language representation learning 분야에서 breakthrough를 가져왔다. 데이터가 부족한 많은 NLP task에서 이러한 방법들은 pre-trained을 효과적으로 적용되어왔다.

다양한 pre-training 방법론들에서 Large size의 network를 사용하는 것이 성능을 향상시키는데 중요한 역할을 했다. 또한, pre-trained large network를 smaller한 network로 distilling시키는 방법들도 많이 제시되었다. 이러한 흐름을 바탕으로 우리는 “더 큰 모델을 가지는 것이 더 좋은 NLP 모델을 만드는 방법인가?” 라는 질문을 한다.

하지만 이러한 질문에 대한 대답에서 문제가 되는 부분은 더 큰 모델을 사용한다는 것은 GPU memory에 제약을 받는다는 점이다. 최근의 다양한 높은 성능을 보이는 모델들을 매우 많은 파라미터들을 가지고 있고, 실제로 이를 이용해보려 하면 memory 제약을 쉽게 경험 할 수 있다.

이러한 memory limitation을 다룬 여러 방법들(model parallelization, clever memory management)이 있었지만 이는 결국 communication overhead는 다루지 못헀다.

따라서 이 논문에서 앞서 언급한 문제점들을 해결하는 더 작은 파라미터를 가진 A Lite BERT(ALBERT) architecture를 소개한다.

ALBERT는 두 가지 parameter reduction 기법을 사용한다.

Factorized embedding parameterization
Cross-layer parameter sharing

첫 번째 Factorized embedding parameterization 방법은 기존의 큰 embedding matrix를 두개의 matrix로 나눠 파라미터 수를 줄였고. 두 번째 Croos-layer parameter sharing은 모델의 깊이가 깊어질 수록 파라미터 개수가 선형적으로 늘어나는 것을 방지한다.

이러한 방법들을 통해 ALBERT는 BERT-large모델에 비해 18배 적은 파라미터를 가지고 1.7배 빠르게 학습된다.

추가적인 성능향상을 위해 ALBERT는 self-supervised loss인 SOP(Sentence order prediction) loss를 사용한다. 이 loss는 기존의 NSP loss의 비효율성을 개선하기 위해 사용한다.

The Elements of ALBERT

Model Architecture choices

ALBERT의 기본 architecture는 BERT와 유사하다. Transformer의 Encoder 구조와 함께 GELU activation function을 사용했다. 여기서 notation은 기존의 BERT에서와 동일하게 사용한다. embedding size는 $E$, encoder layer의 수를 $L$, hidden size를 $H$로 표기한다. 기존 BERT와 동일하게 feed-forward의 size를 $4H$로 attention head 수를 $H/64$로 사용했다.

Factorized embedding parameterization BERT에서 WordPiece embedding size $E$와 모델의 hidden layer size $H$는 동일하게 설정되어 있다. 이러한 설정은 모델링 측면과, 실용적인 부분에 최적의 방법이 아니다.

그 이유에 대해서 얘기하자면 우선 모델링 관점에서 보면, WordPiece embedding 은 context-independent한 representation인 반면 hidden-layer embedding의 경우 context-dependent한 representation이다. RoBERTa: A robustly optimized BERT pretraining approach. 에서의 context length에 관한 실험에서 볼 수 있듯이 BERT-like representation의 효과는 context-dependent한 representation을 학습하는데 있다. 따라서 WordPiece embedding size인 $E$와 hidden layer size인 $H$를 다르게 설정하는 것이 더 효과적인 모델 파라미터들의 활용일 수 있다.

실용적인 관점에서 보면, NLP 모델들은 vocabulary size $V$를 가지는데, 대부분 매우 큰 값을 가진다. 이 떄 앞서 말했던 $E$와 $H$를 동일하게 설정한다면 자연스럽게 embedding matrix의 파라미터 수인 $V \times E$가 커지게 된다. 이 값은 보통 $E=H$ 로 설정한다면 쉽게 10억개 이상의 파라미터를 가지고 학습 속도를 매우 느리게 한다.

따라서 ALBERT에서는 factorization of embedding parameters를 사용한다. 이는 큰 embedding matrix를 작은 두개의 matrix로 나누는 방법으로 먼저 기존에 $E$ dimension으로 바로 mapping 했던 것을 보다 작은 dimension인 $E$로 mapping한 후 $E$ dimension의 vector를 다시 $H$ dimension으로 보낸다. 이렇게 되면 기존에 $V \times H$ 였던 파라미터 수는 $V \times E + E \times H$으로 줄어들게 된다.

Cross-layer parameter sharing ALBERT에서는 cross-layer paraeter sharing 기법을 사용한다. 이는 파라미터를 효율성을 향상시킨다. Parameter를 sharing하는 다양한 방법들이 존재한다. 예를들면 Transformer network에서 FFN(Feed-Forward Network)의 파라미터만 공유하거나, attention parameter만 공유한다던지. ALBERT에서는 모든 parameter들을 공유한다.

Universail Transformer(Dehghani et al., 2018)와 Deep Equilibrium Models, DQE(Bai et al., 2019)에서 이와 유사한 방법이 사용되었다. ALBERT와 다른점은 UT에서는 기존의 vanilla Transformer 보다 높은 성능을 보이고, DQE에서는 특정 layer에서의 embedding의 input과 output이 동일해지는 equilibrium point에 도달한다는 것을 확인 할 수 있다. 우리의 실험에서는 embedding의 L2 distance 및 cosine similarity가 converge 하지 않고 oscillating한 것을 확인 할 수 있다.

위의 그림을 통해 layer를 통한 transition이 ALBERT에서가 BERT에 비해 더 smoother한 것을 확인 할 수 있다. 즉, 이러한 결과는 weight-sharing이 network parameter들을 stabilizing하는데 효과가 있다는 것을 보여준다.

Inter-sentence coherence loss Masked Language Modeling(MLM) loss와 더불어 BERT 는 Next-Sentence Prediction loss를 사용했다. NSP는 입력값으로 들어간 두 문장이 이어진 문장인지, 아니면 관계없는 문장인지를 예측하는 binary classification task이다. NSP는 기본적으로 sentence pair의 관계를 capture하는 downstream task의 성능 향상을 위해 설계되었다. 하지만 최근 RoBERTa(Liu et al., 2019), XLNet(Yang et al., 2019)등 다양한 연구에서 NSP의 효과에 대해서 의문을 제기하고, NSP loss를 제거하고 pre-train을 진행하고 있다. 그리고 이러한 결과는 여러 downstream task에서 성능의 향상을 가져 왔다.

우리는 이러한 NSP의 비효율성의 이유를 task가 MLM에 대비해서 매우 쉬운데에 있을거라 추측한다. NSP는 하나의 task로 topic prediction 과 coherence prediction 두 개의 예측을 진행한다. 이 때 topic prediction 은 상대적으로 coherence prediction에 비해 매우 쉽고, MLM과 겹치는 부분이 상당수이다.

우리는 sentence간의 관계를 보는 modeling이 natural language understanding에 매우 중요한 부분이라 생각하고, 이를 위해 coherence에 기반을 둔 loss를 제안한다. 즉 ALBERT에서는 sentence-order prediction(SOP) loss를 사용한다. 이는 해당 loss가 topic을 예측하지 않고 sentence간의 coherence를 예측하도록 한다.

SOP는 동일한 document에서 가져온 연속된 두개의 segment를 입력값으로 넣는다. 이 때 각각 50%의 확률로 순서를 그대로 넣거나, 순서를 반대로 섞어서 넣는다. 그리고 모델을 통해 순서가 제대로 된 순서인지, 반대로 되어있는지를 예측하도록 한다. SOP에 대한 실험을 보면 SOP를 사용함으로써 NSP를 사용한 성능보다 향상된 것을 확인 할 수 있다.

Model setup

ALBERT에서 BERT와 다르게 설정한 hyperparameter들은 아래와 같다.

앞서 언급한 model design을 통해 ALBERT는 BERT 모델과 비교해서 상대적으로 매우 작은 파라미터 개수를 가진다. 예를들면, ALBERT-large 모델의 경우 BERT-large에 비해 18배 적은 파라미터를 자긴다.

Experiments

Overall Comparison between BERT and ALBERT

Factorized Embedding Parameterization

Sentence Order Prediction(SOP)

A Structured Self-Attentive Sentence Embedding

2019-03-01T04:47:35+00:00

2017 ICLR Conference에서 소개된 논문 중 IBM Watson의 Attention mechanism을 사용해 Sentence embedding을 하는 A Structured Self-Attentive Sentence Embedding 논문에 대해서 알아보도록 한다. 해당 모델은 sentence embedding을 위한 self-attention mechanism과 정규화를 위해 새로운 regularization term을 소개한다. 뿐만 아니라 추가적으로 visualizing을 쉽게 할 수 있도록 설계되어있어 간단하게 visualizing을 할 수 있도록 한다. 해당 모델의 성능을 측정하기 위해서 3개의 task(author profiling, sentiment classification, textual entailment)에서 실험했다.

1 Introduction

Word embedding 기법, 즉 개별 단어들에 대해 유의미한 distributed representation을 학습하는 기법들을 계속해서 많은 발전을 이뤄왔다. 반면 아직 phrase나 sentence의 representation을 만드는 데는 word에 비해 아직은 부족한 상황이다. 보통 이와 같이 phrase나 sentence를 representation하는 방법은 두가지로 나뉜다. 첫 번째는 unsupervised 학습을 사용해 universal sentence representation을 만드는 방법이다.(SkipThought vector, ParagraphVector, recursive auto-encoders, Sequential Denoising Autoencoder, FastSent, etc)

또 다른 방법은 특정 task를 위해 특별하게 학습하는 방법이다. 이러한 방법은 보통 supervised 학습하고, downstream application과 합쳐져서 사용된다. 그리고 몇몇 모델의 경우에는 일반적인 단어 임베딩을 사용하고 중간에 recurrent networks, recursive networks, convolutional networks 등을 사용함으로써 sentence representation을 얻어 다양한 task에 적용되었다.

Attention mechanism을 CNN 혹은 LSTM 네트워크 상단에 적용함으로써 추가적인 정보를 통해 sentence embedding을 추출하는 모델이 몇가지 task에서 제안되었다. 하지만 sentiment analysis 같은 단일 문장이 입력으로 들어가는 경우에 추가적인 정보로 활용할 문장이 없기 떄문에 attention mechanism을 적용할 수 없다.

따라서 대부분의 경우에는 max or average pooling 기법을 적용하거나 RNN의 마지막 hidden vector를 선택해서 사용하는데, 해당 모델에서는 self-attention 기법을 통해서 기존의 방법들을 대체한다. self-attention의 경우에는 추가적인 입력값이 없는 하나의 문장에 대해서도 적용할 수 있고, 긴 문장에 대해서도 좋은 성능을 낸다. 이후 section 2.1 에서 self-attentive sentence embedding 모델을 소개하고 2.2에서 모델에서 사용한 정규화 방법에 대해서 소개한다. 마지막으로 2.3 에서는 효과적으로 해당 기법을 시각화 할 수 있는 방법에 대해서 소개할 것이다.

2 Approach

2.1 Model

Sentence embedding 모델은 크게 두개의 part로 구성되어 있다. 첫 번째 part는 bidirectional LSTM 을 사용하는 부분이고 다음은 self-attention을 적용하는 방법이다. 두 번째 part에서 나오는 값들을 사용해 LSTM의 hidden state값을 weighted sum 하게 되고 이 값이 입력 문장에 대한 embedding vector 로 사용된다. 그리고 이 값을 활용해서 각각의 task에 맞게 추가적인 networks를 모델 상단에 적용시킬 수 있다. 예를 들면 sentence embedding vector에 multi-layer perceptron을 적용시켜서 sentiment analysis task에 적용할 수 있다. 아래의 그림은 해당 예시를 도식화한 그림이다.

모델의 세부 과정에 대해서 자세히 알아보도록 하자. 우선 아래와 같이 $n$개의 token을 가지는 입력 문장이 있다고 하자. 입력 문장은 아래와 같이 각 단어들의 vector들이 모여서 matrix가 된다.

$S = (\mathbf{w_1}, \mathbf{w_2}, ... ,\mathbf{w_n})$

여기서 $\mathbf{w_i}$ 는 $i$번째 단어의 $d$-dimensional vector이다. 입력 문장 $S$ 는 $(n,d)$ 형태가 된다. 해당 입력 문장에 bidirectional LSTM을 적용시켜 두 개의 $u$-dimensional hidden vector 값을 구한다.

$\begin{matrix} \overset{\rightarrow}{h} = \overset{\longrightarrow}{\text{LSTM}}(w_t, \overset{\longrightarrow}{h_{t-1}})\\ \overset{\leftarrow}{h} = \overset{\longleftarrow}{\text{LSTM}}(w_t, \overset{\longleftarrow}{h_{t+1}}) \end{matrix}$

Bidirectional LSTM hidden state인 $\overset{\rightarrow}{h_t}$와 $\overset{\leftarrow}{h_t}$를 concatenate한 결과인 $h_t$를 사용한다. 전체 길이 $n$에 대해 다음과 같이 n개의 hidden state값이 나오게 된다. 이 값들을 모아서 하나의 matrix로 만들면$(n,2u)$의 size를 가지게 된다.

$H=(\mathbf{h_1},\mathbf{h_2},...,\mathbf{h_n})$

가변 길이의 입력값에 대해서 동일한 크기의 embedding 값을 얻는 것을 목표로 하기 떄문에, $n$개의 LSTM state를 적당한 linear combination을 통해 일정한 크기로 만들어 줘야 한다. 여기서는 self-attention mechanism을 linear combination으로 사용한다. Attention mechanism의 입력으로는 $H$를 사용하고, weight로 사용되는 output $\mathbf{a}$가 나오게 된다.

$\mathbf{a} =softmax(\mathbf{w_{s2}}\tanh(W_{s1}H^T))$

여기서 $W_{s1}$은 $(d_a, 2u)$ 크기의 가중치 행렬이고, $\mathbf{w_{s2}}$는 $(d_a)$ dimension의 가중치 벡터이다. 최종 output인 $\mathbf{a}$는 $n$ dimension의 벡터가 나오게 된다. 해당 값은 각 token에 대해 얼마나 반영할지를 확률값으로 표현되어있다. 이 값을 사용해 $H$의 가중 합을 구하게 된다.

$\mathbf{m} = \text{sum}(\mathbf{a}\odot H)$

이 값은 한 문장에 대해서 하나의 semantic 정보를 담고있다. 하지만 일반적으로 문장의 경우 여러개의 의미를 담는경우가 많이 있다. 예를 들면 ‘and’로 연결되어 있는 문장의 경우 한문장이더라도 여러개의 의미를 담고 있다. 따라서 이러한 전체적인 의미를 담은 represent하기 위해서 multiple $\mathbf{m}$을 필요로 한다. 따라서 multiple hops of attention을 사용한다. 문장에서 $r$개의 각각 다른 부분의 의미를 추출하기 위해서 기존의 $\mathbf{w_{s2}}$를 $(r,d_a)$크기의 가중치 행렬로 확장시켜서 다음과 같이 attention matrix를 구하게 된다.

$A = softmax(W_{s2}\tanh(W_{s1}H^T))$

이후 최종 output은 위의 attention matrix $A$와 $H$를 행렬곱해서 얻게된다.

$M = AH$

2.2 Penalization Term

앞서 구한 $M$은 $r$개의 정보를 담아야 하는데 만약 비슷한 값들만을 갖게 된다면 정확한 정보를 전달하기 어려워지는데 이러한 문제를 해결하기 위해 penalization term을 통해 다양한 정보를 각각의 attention hop이 가질 수 있도록 만들어 준다.

다양성을 평가하는 가장 좋은 방법은 Kullback Leibler divergence를 측정하는 것이다. 하지만 해당 모델에서 KL-divergence를 사용한 경우에 unstable하기 때문에 해당 모델에서는 다른 regularization term을 사용해서 Regularization을 한다. 뿐만 아니라 여기서 제시하는 penalization term의 경우 KL-divergence와 비교해서 연산량이 1/3로 cost 측면에서도 효율적이다.

해당 term은 아래와 같이 계산한다.

$P = \Vert (AA^T-I)\Vert_F^2$

여기서 사용한 $\Vert\cdot\Vert_F$은 Frobenius norm이다. L2 regularization term과 비슷하게 해당 term은 coefficient를 곱한 후 loss와 함께 최소화하게 된다.

2.3 Visualization term

해당 모델에서 sentence embedding을 interpretation하는 것은 매우 간단하게 annotation matrix $A$를 사용함으로써 매우 간단히 해결할 수 있다. embedding matrix $M$의 각 row에 대해 각각 상응하는 annotation vector $\mathbf{a}$를 가진다. 각 element는 각 position의 token이 얼마나 contribution을 한지 확인 할 수 있다. 이 값을 사용해 Visualization을 쉽게 할 수 있다. Visualization결과는 다음과 같이 나타난다.

Conclusion & Discussion

해당 논문에서는 self-attention을 사용해서 고정된 크기의 matrix sentence embedding을 만들었다. 해당 모델을 3개의 task에 실험한 결과는 해당 모델의 다른 sentence embedding 모델에 비해 더 좋은 성능을 보인다는 것을 확인할 수 있다.

LSTM의 결과에 attention mechanism을 적용함으로써 LSTM은 마지막 hidden state에 모든 token의 정보를 담을 필요가 없고 단지 각 token의 정보들만을 담으면 된다. 따라서 해당 모델은 sentence의 길이가 길어지더라도 좋은 성능을 보인다.

그리고 해당 모델은 가변 길이의 문장을 하나의 고정된 길이의 representation으로 나타낼 수 있고, long-term의 경우에도 동일하게 정보를 잠 담는다. 이러한 장점은 모델이 scalability 하다는 것을 나타낸다. 따라서 단순 문장이 아니라 paragraph, articles등 더욱 긴 content에도 적용할 수 있다는 것을 볼 수 있다.

BERT: Bidirectional Transformers for Language Understanding

2018-12-06T04:47:35+00:00

이번에는 많은 Task 에서 SotA(State of the Art)의 성능을 보이고 있는 BERT(Bert Encoder Representations form Transformers)에 대해서 알아보도록 하자. 이전에 소개된 ELMo, GPT에 이어 Pre-trained을 함으로써 성능을 올릴 수 있도록 만든 모델이다. 해당 모델은 Google에서 제시한 모델로 BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding 논문에서 소개되었다. 이제 논문을 살펴보자.

1 Introduction

많은 Task 에서 Language model pre-training은 효과적이라는 것을 계속해서 입증해오고 있다. ELMo, OpenAI의 Generative Pre-trained Transformer(GPT) 등 다양한 모델에서 pre-train을 함으로써 대부분의 NLP의 task의 성능이 향상됨을 보여왔다.

우선 여기에는 pre-train 된 언어 표현을 실제 task에 적용시키는 방법은 두 가지로 나뉜다. 하나는 feature-base 방법이고, 하나는 fine-tuning 방법이다.

우선 feature-based 방법의 경우 예시는 ELMo이며, 이 경우에는 ELMo를 통해 사전 학습한 feature를 사용하지만, task에 적합한 새로운 architecture를 추가로 사용해서 task를 해결한다. 즉 사전 학습을 통해 언어 표현 feature만 사용하고, 모델의 경우 별개의 개념인 것이다.

그와 다르게 fine-tuning 방법의 경우 예시는 OpenAI의 GPT이다. 이 방법의 경우 task에 맞게 새로운 task-specific한 parameter를 사용한다. 이 parameter를 각 task에 학습하는데, 이 때 사전 학습한 parameter를 사용해 fine-tuning 하는 방법이다.

이러한 두 방법 모두 같은 목적 함수를 사용해 사전 학습하지만, 두 방법 모두 단방향의 language model을 사용해서 언어 표현을 학습한다.

해당 논문에서는 기존의 이러한 기법들(ELMo, GPT)이 pre-train된 표현의 제대로된 성능을 저해하는 요소가 있다고 주장한다. 이러한 요소에 대해서 설명하면, 먼저 이러한 langugage model 이 단방향으로 학습한다는 점이다. 그리고 이러한 이유로 pre-train 과정에서 사용될 architecture를 선택할 수 있는 폭을 줄어든다는 점이다.

예를 들어 OpenAI의 GPT의 경우 텍스트에서 왼쪽에서 오른쪽으로만 참고할 수 있는 구조를 취하고 있다.

따라서 해당 논문에서는 fine-tuning based 방법으로 BERT: Bidirectional Encoder Representations from Transformers 를 사용함으로써 성능을 향상시킬 것이다. 해당 방법의 경우 기존의 방법이 단방향이였다면, “masked language model(MLM)“를 통해 사전학습을 함으로써 이러한 제약을 해결할 것이다.

Masked language model은 임의로 input token의 몇가지를 masking 처리하고, 다른 token들을 사용해서 masking된 token들을 예측하는 방향으로 학습한다. 기존의 왼쪽에서 오른쪽으로 단방향으로만 사전 학습하는 모델과는 다르게 MLM의 목적은 좌,우의 모든 문맥이 융화되도록 하는 것이다.

그리고 Masked language model과 더불어 “next sentence prediction” 라는 task를 사전 학습 과정에서 같이 사용할 것이다.

마지막으로 해당 논문이 기여하려고 하는 바는 다음과 같다.

해당 논문에서는 언어 표현을 위해 양방향으로 사전 학습하는 것의 중요성을 증명할 것이다. OpenAI의 GPT 처럼 단방향으로 사전 학습을 하지 않고 BERT는 masked langugage model을 사용해 언어 표현을 위한 양방향으로 사전 학습을 진행한다. 그리고 ELMo의 경우 좌에서 우, 우에서 좌 둘다 사용해서 양방향이라 표현할 수 있지만, 해당 논문에서는 좌에서 우, 우에서 좌로 각각 학습한 후 이를 concatenate 해서 사용했다는 점이 BERT와의 차이점이다.
또한 많은 engineering이 필요한 task-spesific한 architecture를 사용할 필요성을 사전 학습을 통해 줄여준다. BERT는 문장 단위와 단어 단위 모두에서 SotA의 성능을 보이는 최초의 fine-tuning 기반의 표현(representation) 모델이다.
BERT를 사용함으로써 11개의 NLP task들에서 SotA의 성능을 향상시켰다. 그리고 BERT를 통해 양방향 특성이 가장 중요한 점이라는 것을 보여준다. 그리고 code와 pre-trained 모델의 경우 goo.gl/language/bert에서 사용할 수 있다.

먼저 사전 학습 모델의 역사에 대해서 간략하게 알아보도록 하자.

2.1 Feature-based Approaches

우선 Feature based 한 Pre-trained 기법들을 Neural이 아닌 모델들도 많이 있었다. 그리고 Pre-trained 시 단순히 단어에 대한 임베딩만을 진행하는 것이 아니라, 문장 및 구절에 대해서도 임베딩 하기도 한다.

그 중에서도 ELMo는 이러한 전형적인 단어 임베딩 연구를 다른 차원으로 일반화 시켰다. ELMo 모델에서는 context-sensitive 특징을 모델을 통해 추출했다.

2.2 Fine-tuning Approaches

최근의 Langugage model에서 tansfer learning의 트렌드는 실제 task에 맞는 지도 학습 모델을 적용하기 전에 동일한 모델을 사전 학습한 후 학습한 결과를 사용해서 fine-tuning하는 방법이다. 이러한 방법의 장점은 학습해야 하는 parameter의 수가 적다는 점이다. 더 적은 수의 parameter를 학습하면 된다.

2.3 Transfer Learning from Supervised Data

비지도 학습의 사전 학습 방법은 무한정의 데이터를 사용할 수 있다는 장점이 있지만, 큰 데이터에 대해서 지도 학습 방법의 transfer가 더욱 효과적이라는 것이 입증되었다.

3 BERT

이제 본격적인 BERT의 세부적인 구현 내용에 대해서 알아보도록 하자. 순서는 우선 전체 모델의 architecture에 대해서 알아보고 input의 형태를 먼저 알아본다. 그리고 다음으로 pre-training task에 대해서 알아본 뒤 pre-training, fine-tuning의 세부적인 절차에 대해서 알아본다. 마지막으로 BERT와 OpenAI GPT의 차이점에 대해서 다뤄보도록 한다.

3.1 Model Architecture

BERT의 모델 구조는 multi layer의 양방향 Transformer 인코더를 기반으로한 구조이다. Transformer에 대한 자세한 설명은 생략하도록 한다.(블로그 글 참고)

해당 모델의 트랜스 포머의 layer의 수(Transformer 블록의 수)는 $L$로 지칭하고, hidden size는 $H$로 지칭한다. 그리고 self-attention의 head 수는 $A$로 지칭한다. 마지막으로 Transformer의 feed-forward layer의 첫번째 layer의 unit 수는 $4H$로 지정한다.

해당 모델에서는 2개의 각각 다른 하이퍼 파라미터를 가지는 모델을 정의했다. 각 모델의 하이퍼 파라미터 값은 다음과 같다.

$\text{BERT}_\text{BASE}$: $L=12, H=768, A=12, \text{Total Parameters} = 110M$
$\text{BERT}_\text{LARGE}$: $L=24, H=1024, A=16, \text{Total Parameters} = 340M$

$\text{BERT}_\text{BASE}$는 비교를 위해 OpenAI의 GPT 모델과 같은 크기로 설정했다. BERT와 OpenAI의 GPT와 ELMo의 모델의 차이점은 아래의 그림을 참고하자.

3.2 Input Representation

이제 입력값의 형태에 대해서 알아보도록 하자. 여기서 입력값의 형태는 약간 모호할 수 있다. 하나의 문장이 입력값이 될 수도 있고 두개의 문장 쌍(e.g. [Question, Answer])이 입력값이 될 수도 있다. 주어진 token에 대해서 다음의 세가지 값을 더함으로써 입력값으로 사용한다.

Token의 Embedding
Segment의 Embedding
Position의 Embedding

위의 세가지 값을 더하면 입력값이 된다. 입력값에 대한 부분은 아래의 그림을 참고하자.

입력값에 대한 구체적인 특징들은 다음과 같다.

30,000개의 token vcabulary를 가지는 WordPiece 임베딩 값(Wu et al., 2016)을 사용했다. 그리고 split word의 경우 ##으로 사용했다.
그리고 Positional 임베딩 값으로는 512 토큰 길이에 맞게 학습된 임베딩 값을 사용했다.
모든 문장의 첫 토큰은 special classification embedding값([CLS])을 넣어준다. 해당 토근에 대응하는 마지막 hidden state(Transformer의 출력값)는 분류 task에서 사용된다. 만약 분류 task가 아니라면 해당 벡터는 무시한다.
문장 쌍은 하나로 묶여서 하나의 문장으로 만들어지는데, 실제로 다른 이 문장 쌍을 두가지 방법으로 구별한다. 첫 번쨰는 두 문장 사이에 special token([SEP])를 넣어주고, 두 번째 방법은 학습된 문장 A 임베딩 값을 앞쪽 문장 모든 token에 더해주고 문장 B 임베딩 값을 뒤쪽 문장 모든 token에 더해준다.
단일 문장 입력값의 경우 문장 A 임베딩 값만을 사용한다.

3.3 Pre-training Tasks

해당 모델에서는 전형적인 좌에서 우 혹은 우에서 좌로 가는 language model을 사용해서 BERT를 pre-train하지 않았다. 대신 BERT는 두개의 비지도 예측 task들을 통해 pre-train 했다. 이 Section에서 두개의 비지도 학습 task에 대해서 알아보도록 하자.

3.3.1 Task #1: Masked LM

직관적으로 양방향 모델이 기존의 좌->우 / 우->좌 모델보다 훨씬 더 좋다는 것은 합당하다. 하지만 불행이도 양방향 조건은 간접적으로 각 단어를 본인 스스로를 보도록 하기 때문에, 일반적인 조건부 language model은 오직 좌에서 우, 우에서 좌로만 학습할 수 있다. 따라서 양방향 학습을 위해서 여기서는 특정 확률만큼에 해당하는 입력 토큰들을 임의로 마스킹 처리한다. 그리고 마스킹 된 단어들을 예측하도록 한다. 이러한 기법을 “masked LM”이라 부른다.(MLM) denoising auto-encoders와는 대조적으로 여기서는 오직 masking 한 값만 비교를 해서 학습을 진행한다.

이러한 MLM 기법을 통해서 양방향 학습이 가능하도록 했지만, 이러한 기법의 큰 두가지 문제점이 남아있다. 첫 번째는 pre-train 과정에서는 “[MASK]” 토큰을 사용하지만, fine-tuning 한 후에는 사용하지 않아서 pre-train과 fine-tuning 사이의 간극이 생긴다는 점이다. 이러한 문제점을 해결하기 위해 학습 과정에서 모든 masking된 값을 [MASK] 토큰으로 대체하지 않았다. 자세하게 이러한 문제점을 해결하는 방법에 대해서 알아보도록 하자. 예를 들어 “내 개는 크다” 라는 문장이 있다고 하자. 이 때 “크다” 라는 단어를 masking 하려고 한다면 다음과 같이 진행된다.

항상 “크다” 라는 단어를 [MASK] 토큰으로 대체하는 것이 아니라 다음과 같이 진행한다.
전체 시간의 80%: “크다” 라는 단어를 “[MASK]” 토큰으로 대체한다. 즉 “내 개는 크다” $\rightarrow$ “내 개는 [MASK]”
전체 시간의 10%: “크다” 라는 단어를 임의의 다른 단어로 대체한다. 즉 “내 개는 크다” $\rightarrow$ “내 개는 사과”
전체 시간의 10%: Masking 된 단어, “크다” 를 그대로 둔다. 즉 “내 개는 크다” $\rightarrow$ “내 개는 크다”

위와 같이 masking 함으로써 pre-train과 fine-tuning 과의 간극을 줄여서 첫 번째 문제점을 해결한다. 두 번째 MLM의 문제점은 오직 15%의 token 만 각 batch 에서 예측된다는 점인데, 따라서 pre-train 값이 수렴하기 위해서는 더 많은 step을 학습해야 한다.

위 그림을 보면 MLM 기법을 사용한 BERT 모델이 단방향의 BERT 모델 보다 더 많은 step이 지나야 수렴한다는 것을 확인할 수 있다.

3.3.2 Task #2: Next Sentence Prediction

Question Answering, Natural Language Inference 등의 Task들은 두 문장 사이의 관계를 이해하는 것이 매우 중요하다. 문장 사이의 관계를 모델이 학습할 수 있도록 단일 Corpus로 구성된 두 개의 문장에 대해 문장이 관계있는지 없는지 이진 분류하는 next sentence prediction task를 통해 pre-train 한다. 구체적으로 두개의 A, B 문장을 선택하는데, 학습 과정에서 절반은 B 를 실제 A의 다음 문장으로 선택하고, 나머지는 임의의 다른 문장을 선택한다. 아래의 예를 보자.

$\begin{align*} \text{Input} = &\text{[CLS] the man went to [MASK] store [SEP]}\\ &\text{he bought a gallon [MASK] milk [SEP]}\\ \text{Label} =&\text{IsNext} \end{align*}$ $\begin{align*} \text{Input} = &\text{[CLS] the man [MASK] to the store [SEP]}\\ &\text{penguin [MASK] are flight ##less birds [SEP]}\\ \text{Label} =&\text{NotNext} \end{align*}$

NotNext 문장의 경우 완전히 임의로 선택했다. 해당 테스크에 대해서 최종적으로 pre-train된 모델의 경우 97~98%의 정확도를 보여준다. 이러한 task는 QA 와 NLI task에 대해서 아래와 같은 성능 향상을 보여줬다.

3.4 Pre-training Procedure

pre-traning Corpus를 위해 두개의 Corpus를 합쳐서 사용했다. BooksCorpus(800M words)와 Engish Wikipedia(2,500M words)를 합쳐 하나의 Corpus로 만들었다. Wikipedia corpus의 경우 list, tables, header를 모두 무시하고 text만을 추출했다.

각 학습 입력값을 만들어주기 위해서 두개의 문장을 뽑아서 하나의 문장으로 만들어 준다. 첫 번쨰 문장의 경우 A 임베딩 값을 가지고 두 번째 문장의 경우 B 임베딩 값을 가진다. B의 50%는 실제 A의 다음 문장을 사용하고 나머지는 임의의 문장을 사용한다. 이렇게 뽑아 “next sentence prediction” task에 사용한다. 그리고 두 문장을 합친 문장의 최대 길이는 512 토큰으로 제한한다.

학습 시 batch size의 경우 256 문장으로 한다. 따라서 한 batch에 총 256 sequence $\times$ 512 tokens 인 128,000개의 토큰이 학습된다. 또한 전체 step은 1,000,000번 으로 33억개의 단어 corpus에 대해서 대략 40 에폭정도 학습한다.

또한 학습은 Adam 을 사용하였으며 하이퍼 파라미터 값은 다음과 같다.

Learning rate: $10^{-4}$
$\beta_1 = 0.9$
$\beta_1 = 0.999$
0.01 값으로 L2 가중치 감소 사용
Learning rate의 경우 10,000 스탭마다 선형으로 감소하도록 함

그리고 드랍아웃의 경우 0.1 확률로 모든 레이어에 적용했다. 활성화 함수로는 gelu를 사용했다. 학습 loss의 경우 mean masked LM likelihood and mean next sentence prediction likelihood를 더한 값을 사용했다.

3.5 Fine-tuning Procedure

문장의 classification task는 BERT의 fine-tuning이 직관적이고 간단한다. 입력값에 대해서 고정된 길이의 벡터를 추출해야 하는데, 해당 모델에서 첫 번째 입력값인 [CLS] 토큰에 의해 출력되는 마지막 hidden state값을 사용한다. 이 벡터를 $C\in\mathbb{R}^H$라 부른다. fine-tuning 과정에서 전체 파라미터는 그대로 유지되지만 마지막 classification을 위해 classification layer $W\in\mathbb{R}^{K\times H}$를 추가한다. 여기서 $K$는 classification 해야 되는 라벨의 개수를 의미한다. 해당 layer를 거친 벡터에 대해서 소프트맥스 함수를 적용시켜 확률 벡터인 $P\in\mathbb{R}^K$를 계산한다. 즉 아래의 수식과 같이 최종 확률 벡터가 계산된다.

$P = \text{softmax}(CW^T)$

BERT의 모든 parameter와 $W$는 실제 라벨과 비교한 log-probability 를 최대화 하며 학습된다. 사실 이러한 최종적인 fine-tuning과정과 학습 방법은 task에 따라 조금은 달라지는데 아래의 그림을 참고하자.

fine-tuning 과정에서 대부분의 모델의 hyper parameters는 pre-train 과정과 동일하게 진행하지만, batch size, learning rate, epoch 값은 변경한다.

그리고 대부분의 최적의 hyper parameters는 task마다 매우 다르다.

4 Conclusion

최근의 language model 에서의 transfer leaning의 효과가 입증되었다. 그리고 비지도 학습의 pre-training 이 대부분의 language understanding의 한 부분으로 통합되었다.

해당 논문을 통한 가장 큰 기여는 양방향의 구조를 통해 pre-train 모델이 대부분의 NLP 모델에 성공적으로 적용된다는 점이다. 대부분의 결과가 매우 성공적이지만, 일부 사람의 성능보다 떨어지기도 하기 때문에 더 많은 연구를 통해 BERT에 의해 잡지 못하는 언어적 현상을 잡도록 해야 한다.

End to End Memory Network

2018-10-07T09:47:35+00:00

지난 포스트인 Memory Network에 이어 다음 논문으로 볼 수 있는 End to End Memory Network 논문을 소개한다. 기존의 Memory Network의 경우 모델의 전 과정이 supervised 하기 떄문에 일반적으로 사용하기 어렵고 제약된 사항이 많았으나, 해당 논문의 경우 이름을 보면 알 수 있듯 End to End 한 모델을 제시해서 사용하기 쉽도록 구성되어있다. 이전 논문을 읽지 않았다면 읽은 후에 이 글을 읽도록 하자.

Memory Network
End-to-End Memory Network[현재글]

Introduction

최근 모델에서 attention의 개념과 부가적인 storage를 도입함으로써 모델의 성능을 향상시켰다. “Memory Network”, “Neural machine translation by jointly learning to align and translate”, “Neural turing machines” 에서 소개된 모델을을 보면 continuous한 representation을 저장하는 저장소를 따로 사용하고 있다. 그리고 이 값들을 읽고 모델의 일부분으로 사용을 한다.

해당 논문에서는 continuous한 형태의 Memory Network 모델을 소개한다. 기존의 memory network의 경우 backpropagation을 통해 학습이 어려웠고, 각 component, 즉 각 layer에서 supervised 하기 때문에 제약이 있었다는 단점이 있다. 이러한 문제를 해결하기 위해 end to end로 학습할 수 있는 모델을 제시한다. 따라서 이 모델은 기존의 모델보다 unsupervised한 성격의 모델로 제약없이 많은 task에 적용할 수 있을 것이다.

Approach

모델에서 input 값으로 discrete 한 값인 $x_1, x_2,…,x_n$를 받는다. 이 값들은 하나를 제외한 전부는 memory로 저장될 것이고 하나는 질문(query) $q$이다. 그리고 output은 이 질문에 대한 대답인 $a$가 나온다. memory $x_i$, query $q$, answer $a$ 는 모두 $V$개의 단어들의 dictionary들의 값들로 구성된다. input 값들은 multiple hop 구조를 통해 continuous한 output인 $a$ 값을 만든다. 이러한 구조는 backpropagation을 통해 학습이 쉽도록 만든다. 모델의 전체적인 구조는 아래의 그림과 같다.

위의 그림의 (a)인 왼쪽 그림은 전체 구조에서 하나의 layer를 나타내고 오른쪽 그림인 (b)는 이 layer들이 쌓여 전체 구조를 나타낸다. (a), (b)를 각각 나눠 따로 설명한다.

Single Layer

앞서 말했듯이 모델은 multiple hop 구조를 가진다고 했다. 전체 모델을 소개 전에 우선 하나의 layer에 대해서 먼저 설명한다. multiple hop 구조는 이 single layer가 여러개 쌓인 형태이므로 간단하다.

Input memory representation

우선 input값 중 $x_1,x_2,…,x_i$는 memory에 저장된다. 저장될 떄는 d-차원의 embedding vector로 변환된 후 저장된다. 따라서 ${x_i}$는 ${m_i}$로 storage에 저장된다. 이 때 embeddng vector를 만들기 위해 embedding matrix $A\in\mathbb{R}^{d\times V}$를 곱한다. 그리고 질문(query)도 embedding 된다. 이 때는 $A$와 같은 형태를 가지는 embedding matrix $B$를 곱한다. embedding 된 질문은 internal state $u$ 라 부른다. 다음으로는 질문과 문장들의 연관도를 구하기위해 각각의 $m_i$과 $u$를 각각 곱한 후 softmax를 취해서 계산한다. 이 값은 각 sentence와 query와의 연관성을 계산한 후 확률 벡터로 만들어준다고 생각하면된다. 즉 어떤 문장이 질문에 대해 연관성이 높은지를 계산한 값이다. 이 값을 확률 벡터 $p$라 부른다.

$p_i=\text{Softmax}(u^Tm_i)$

Ouput memory representation

위에서 각 ${x_i}$를 ${m_i}$로 만든 것처럼 똑같이 embedding한 output vector인 $c_i$들을 계산한다. 계산은 embedding matrix $C\in\mathbb{R}^{d\times V}$ 이 값을 output 값을 만들기 위해 사용된다. 그리고 최종 response를 만들기 위해 위에서 계산한 확률 벡터와 output vector를 가중평균한다. 이렇게 최종 response인 $o$를 만든다.

$o=\sum_ip_ic_i$

여기서 사용된 함수들은 smooth한 함수들이기 때문에 gardient를 계산하기 쉽다. 따라서 backpropagation을 통해 학습이 쉬워진다. 그리고 여기서 가중평균한 개념은 self attention과 유사한 개념이다.

Generating the final prediction

이제 최종 response를 통해 마지막 prediction값을 계산해야 한다. 이 떄 response와 계산하기 위해 질문 벡터(query vector)를 embedding 한 vector인 $u$를 사용한다. 두 벡터를 더한 후 가중치 행렬인 $W$를 곱한 후 Softmax 함수를 취해서 최종 prediction을 계산한다.

$\hat{a}=\text{Softmax}(W(o+u))$

여기까지하면 Single layer의 모델이 끝이난다. 총 4개의 parameter matrix $A,B,C,W$가 있고 학습의 경우 prediction 값인 $\hat{a}$와 실제 label $a$를 비교한 cross-entropy loss 함수를 사용하고 update는 SGD를 사용한다.

Multiple Layers

이제 위의 single layer를 확장해 전체 모델을 만들어 보자.위의 layer를 K개 쌓아서 만들면 된다. 이 때 몇 가지 특징이 있는데 다음과 같다.

첫 번째 layer를 제외한 layer의 질문(query) 벡터는 이전 layer의 output vector인 $o^k$와 query vector 인 $u^k$를 더한 값을 사용한다.

$u^{k+1} = u^k+o^k$

각 layer는 모두 다른 embedding matrix $A^k, C^k$를 사용한다. 하지만 parameter를 줄이기 위해 가중치를 공유할 수 있다 이는 밑에서 설명한다.
마지막 layer에서 계산하는 prediction은 다음과 같이 계산된다.

$\hat{a}=\text{Softmax}(Wu^{K+1})=\text{Softmax}(W(u^{K}+o^K))$

그리고 앞서 말했던 parameter를 줄이기 위한 방법으로 두 가지 방법이 사용될 수 있다.

1. Adjacent

인접한 embedding matrix를 같은 weight를 사용하게 함으로써 paramter 수를 줄이는 방법이다. 즉 모든 $k$에 대해 아래의 식들을 만족한다.

$A^{k+1}=C^k$ : 이전 layer의 $C$ matrix 와 해당 layer의 $A$ matrix는 같다.
$W^T=C^K$ : prediction을 위한 matrix은 $W$는 마지막 layer의 $C$ matrix를 transpose한 것과 같다.
$B=A^1$ : query를 embedding 하는 matrix인 $B$와 첫 layer의 $A$ matrix는 같다.

2. Layer-wise(RNN-like)

여기서는 여러 matrix가 생기는 $A$와 $C$들이 각각 모두 같은 matrix를 사용하도록 한다. 즉 아래의 식을 만족한다.

$A^1=A^2=...=A^K$ $C^1=C^2=...=C^K$

그리고 이 경우에는 추가적인 linear mapping 함수인 $H$를 사용한다. 이 함수는 $u$ vector를 다음 값으로 넘길 때 사용된다.

$u^{k+1}=Hu^k+o^k$

여기까지가 전체 모델에 대한 설명이다. 전체적으로 기존 memory network의 모델인 menNN과 비슷한 형태를 취하고 있다. 가장 큰 차이점으로는 QA task에서 질문에 답하기 위해 모든 sentence를 필요로하지 않고 몇 개의 sentence만 필요로한다. 기존 모델인 menNN의 경우에는 이렇게 몇 개의 질문만을 사용하기 위해 supporting subset을 명시적으로 지정하고 학습 시 계속해서 따로 분리시키는데, 해당 모델에서는 이러한 과정없이 한번의 계산으로 질문과 유사한 문장들을 계산하기 때문에 End to End 한 모델이 될 수 있는 것이다.

그리고 학습에 사용된 몇 가지 세부적인 특징은 다음과 같다.

Training data의 10%를 Validation data로 사용
update 시 learning rate 는 0.01 사용, 매 25 에폭마다 절반으로 줄였고 총 100에폭동안 학습
가중치의 경우 평균 0, 표준편차 1인 정규 분포를 따르도록 했다. $\sim N(0,1)$
Batch size 32
학습시 gradient 값의 $l_2 norm$이 40보다 커질 경우 더 커지지 못하고 40을 가지도록 함.
K=3 으로 지정
파라미터를 줄이는 방법으로는 앞서 설명한 adjacent weight sharing 방법 사용

그리고 모델에 추가적으로 사용된 기법들에 대해서 알아보자.

Sentence Representation

문장의 경우 두 가지 representation 방식을 사용했다. 처음으로는 bag-of-words(BoW)를 사용했는데, 이 방식을 사용할 경우 단어들의 위치 정보를 반영하지 못하는 단점이 있다. 따라서 위치 값을 encoding해서 representation을 하였다.

$m_i = \sum_j l_j\otimes Ax_{ij}$

위 식에서 $l_j$가 위치 정보를 담은 값이다. 그리고 이 값은 아래의 수식 값을 가진다.

$l_{kj}=(1-j/J) - (k/d)(1-2j/J)$

이렇게 위치 정보를 embedding 하는 방법을 position encoding(PE)라 부른다.

Temporal Encoding

하나의 정보에 대해 두 가지 선택지가 나오는 경우가 있다. 예를 들어 특정 사람이 두 위치에 다녀왔고, 현재 위치를 물어보는 경우를 대비해서 temporal context의 개념을 사용했다. 이 방식은 memory vector인 $m_i$ 와 output vector인 $c_i$ 계산시 사용된다.

$m_i = \sum_j Ax_{ij}+T_A(i)$ $c_i=\sum_jCx_{ij}+T_C(i)$

여기서 사용된 $T_A$ 와 $T_C$는 temporal 정보를 가지는 matrix이고, 학습 시 같이 학습되는 가중치이다.

Result & Conclusion

이 모델도 결과는 따로 설명하지 않는다. 우선 이전의 모델과 비교하면 성능 자체는 약간 떨어지지만 End to End 로 학습한다는 것에 의미가 있고, 다른 task에 적용하기 쉽다는것이 해당 모델의 큰 장점이다. 이후 Dynamic Memory Network(DMN) 모델도 추가적으로 나왔으므로 이후에 같이 학습하면 도움이 될 것이다.

오역 및 잘못된 내용이 있을 수 있습니다. 잘못된 부분 혹은 이해가 잘 안되는 부분은 댓글 혹은 메일로 말씀해주시면 감사하겠습니다!

Memory Network

2018-10-05T06:47:35+00:00

이번에 리뷰할 논문은 Memory Network입니다. Memory network 중 첫 논문으로 이 모델에서 중점적으로 보는 부분은 memory를 사용해서 긴 text에서 필요한 부분만 저장해서 사용할 수 있도록 하는 것입니다. 주로 Question Answering Task에 실험했으며, QA task를 여러 경우로 나눠서 모델을 구성했습니다. 이 모델의 경우 QA 분야가 아니라 Text generation 등 다른 분야에서 사용할 수 있으며 넓은 범위로 의미있는 논문이므로 자세히 리뷰를 통해 자세히 알아보겠습니다. 해당 Post 이후 향후 이 논문 이후에 나온 “End-to-End Memory Network” 까지 알아봄으로써 Memory Network에 대해 자세히 다룰 예정입니다.

Memory Network[현재글]
End-to-End Memory Network

Introduction

대부분의 머신러닝 모델은 long-term component를 잘 읽고 사용하지 못한다. 예를 들면 전체 소설을 읽고 주제를 말하는 것과 같은 질문을 답하기는 어렵다. RNN 모델을 사용하면서 이런 long-term을 잘 읽을 수 있게 되긴 했지만, 결국 이 memory가 hidden state vector & weights 로 저장되는데, 크기 자체가 크지않고 제한적이다.

따라서 여기서는 momory network라 불리는 모델을 통해 이러한 문제를 해결하고자 한다. 핵심 idea는 머신러닝에서 효과적인 학습 전략과 memory component를 결합해서 사용하는 것이다. 이제 모델에 대해서 알아보자.

Memory Network

Memory Network는 메모리 $\mathbf{m}$(객체 $\mathbf{m}_i$ 들의 배열, 여기서 말하는 객체는 vector 혹은 string을 뜻한다)와 4개의 component인 $I,G,O,R$로 구성된다. 여기서 말하는 4개의 component의 역할은 다음과 같다.

$I$: (input feature map) input을 내부적인 feature 표현으로 바꿔준다.
$G$: (generalization) 새로운 인풋을 통해 기존의 memory를 update한다. 이러한 과정을 genralization이라 부른다.
$O$: (output feature map) 새로운 input과 현재 memory의 값들을 사용해 output을 만든다.
$R$: (response) output을 원하는 포맷의 response로 만들어 준다. 예를 들면 터를 text 혹은 action 으로 바꿔준다.

위의 4가지 component에 대한 설명은 범용적인 개념으로 설명되어 있다. 따라서 해당 모델이 사용한 것에 맞게 component들을 설명하면 다음과 같다.

$I$: input 값을 bag-of-word를 사용해서 embedding 해준다.

$G$: embedding 한 vector를 남아있는 memory slot $m_n$ 에 저장한다. 이 경우에 기존것이 삭제 될 수 있다.

$O$: 모든 memory 값에 대해서 k번 loop를 돌며 match되는 값을 찾고 최종적으로 output $o$를 만들어낸다. (아래 loop은 k=2 인 경우)

1st - input 값과 가장 match score가 높은 memory slot $m_i$를 찾는다.

2nd - input 과 이전 loop에서 찾은 memory slot $m_i$를 같이 사용해 다음으로 match score가 높은 memory slot인 $m_j$를 찾는다.

input과 $m_i,~m_j$ 모두 사용해 output 값을 만든다.

$R$: (reponse) output을 사용해 dictionary의 모든 word들의 score를 계산해 하나의 word를 찾는다.

즉 전체 모델은 memory와 4개의 component들을 사용하는 구조이다. 모델의 전체적인 그림은 다음과 같다.

이제 모델에 대해 자세히 알아보자. 모델은 input $x$가 다음의 순서로 모델에 흘러간다. 여기서 input 값은 charcter, word, sentence등이 될 수 있다.(image or audio signal이 될 수도 있다)

input $x$를 feature 표현으로 바꾼다. 즉 embedding한다: $I(x)$.
새로운 input으로 memory를 update한다: $\mathbf{m}_i=G(\mathbf{m}_i,I(x),\mathbf{m}), \forall i$.
input과 memory를 이용해 output $o$를 계산한다: $o=O(I(x),\mathbf{m})$
마지막으로 output을 decode해서 최종 response를 만든다: $r=R(o)$

위의 process는 학습과 테스트 모두에 적용된다. 학습과 테스트의 다른점은 학습시에는 memory와 4개의 component인 $I,G,O,R$모두 update되는데 테스트 때는 memory만 update된다.

그리고 memory netword의 해당 모델은 범용적으로 제안된 모델로 각각의 component들은 기존의 machine model 어느 것을 사용해서 구현할 수 있다.(e.g SVMs, decision tress, etc.)

이제 각 component들 각각에 대해서 자세히 살펴보자.

$I$ - component

$I$ component는 전처리의 표준으로 사용할 수 있다. 예를 들면 text input을 parsing, coreference, entity resolution 등을 하는 과정을 넣을 수 있다. 이러한 과정을 통해 raw한 input값을 feature 표현(representation)으로 만든다. 즉 text 를 feature vector로 만들어 준다.

$G$ - component

component $G$의 가장 간단한 형태는 $I(x)$를 memory의 “slot”에 저장하는 것이다. 즉 아래의 식을 수행하는 것이 component $G$가 된다.

$\mathbf{m}_{H(x)}=I(x)$

여기서 $H(.)$는 저장될 slot을 선택하는 함수이다. 즉 $G$는 memory의 배열 중 index $H(x)$의 메모리인 $\mathbf{m}_{H(x)}$를 update한다. $G$는 구현 방법에 따라 기존에 slot에 저장된 memory를 모두 제거하거나 부분적으로 제거한 후 update한다.

그리고 만약 memory가 커질 경우에는 memory를 조직화할 필요가 있다. 이 때 Hash 함수를 사용해 choosing 함수인 $H(x)$를 구현한다. 그리고 이 함수는 경우에 따라 주제나 개체에 따라 저장되는 곳이 함수를 통해 지정될 수 있다. 즉 choosing 을 모든 slot에 대해서 적용하는 것이 아니라, 조직화한 후 적용되는 부분 slot에 대해서만 choosing한다.

그리고 만약 메모리가 가득 찼다면 “foregetting”이라는 $H$를 통해 구현해야 한다. 즉 $H$는 각 메모리의 사용에 대한 점수를 측정하고 점수가 낮은 memory를 제거한 후 update한다. 이런 forgetting에 대한 부분은 이 논문에서 구현하고 실험하지 않았다.

$O$ and $R$ components

$O$ component는 memory를 읽고 inference 과정을 수행한다. 예를 들어 연관성이 높은 memory와 계산하고 output을 만들어낸다. 그리고 $R$ component는 output으로 부터 최종 결과물을 만들어 낸다. Question answering 분야로 생각해보면, $O$를 통해 연관성 높은 memory 와 계산을 해서 output을 만들고 $R$을 통해 해당 output을 다시 실제 답변 text로 만들어 낸다.

A MenNN Implementation for Text

Memory Network 구현의 하나의 예시로 각 components를 Nerual network로 구현했다. 따라서 이러한 모델을 memory neural networks(MenNNs)라 부르고, 이번 section에서 이러한 방법으로 구현한 모델에 대해서 설명한다. 그리고 이 모델의 input과 output은 text인 경우를 다룰 것이다.

Basic model

우선 기본적인 모델의 Architecture에 대해서 알아보자, $I$ 모듈은 text를 input으로 받는다. 여기서는 우선 text가 문장(sentence)라고 생각하자. 그리고 이 문장은 질문이 될수도 있고 사실들이 적혀있는 글일 수 있다. 그리고 text는 가능한 memory slot에 저장된다. 즉 $S(x)$를 통해서 비어있는 memory slot $N$을 찾고 해당 메모리에 input을 저장한다: $\mathbf{m}_N=x,~N=N+1$. $G$ 모듈은 새로운 메모리 저장에만 사용되고 이미 저장된 메모리는 건들지 않는다.

추론(inference)의 핵심은 $O$와 $R$ 모듈이다. $O$ 모듈은 input $x$에 대해 $k$개의 supporting memory를 찾는다. $k=2$로 예를 들어보자. 총 2번의 loop을 돌게되는데 첫 번째 loop에서는 input과 가장 match score가 높은 memory를 찾는다.

$o_1 = O_1(x,\mathbf{m})=\underset{i=1,...,N}{\arg\max}~s_O(x,\mathbf{m}_i)$

여기서 함수 $s_O$는 input 문장과 하나의 memory $\mathbf{m}_i$와의 match score를 측정한다. 그리고 이제 두 번째 loop에서는 input과 이전에 찾은 memory 를 같이 사용해 다음 match score가 높은 memory를 찾는다.

$o_2 = O_2(x,\mathbf{m})=\underset{i=1,...,N}{\arg\max}~s_O([x, \mathbf{m}_{o_1}],\mathbf{m}_i)$

최종 output $o$는 $[x,\mathbf{m}_{o_1},\mathbf{m}_{o_2}]$ 가 된다. 그리고 이 값은 module $R$의 input으로 사용된다.

마지막으로 $R$ 모듈은 위의 input값을 사용해 text response인 $r$을 만든다. 가장 간단한 형태로 response를 만드는 방법은 $k$ loop을 돌며 나온 결과 중 마지막 memory인 $\mathbf{m}_{o_k}$를 text로 만드는 방법이다. 만약 sentence generation을 해야 된다면 하나의 예로 RNN모델을 사용해 generation 할 수 있다. 해당 논문에서의 실험에서는 text response를 단일 단어로 제한해서 모델을 만들었다. 이 경우에는 $O$의 output으로 나온 값들과 vocabulary $W$의 모든 단어들과의 score를 측정해서 가장 높은 score를 가지는 단어를 response로 출력한다. 즉 다음의 수식을 통해 $r$을 만든다.

$r = \underset{w\in W}{\arg\max}~s_R([x,\mathbf{m}_{o_1},\mathbf{m}_{o_2}],w)$

예를 통해 모델을 이해해보자. 우선 아래의 문장을 input으로 사용한다고 하자.

Joe went to the kitchen. Fred went to the kitchen. Joe picked up the milk.
Joe travelled to the office. Joe left the milk. Joe went to the bath room

위 문장에 대해서 다음의 질문들이 주어진다고 하자.

Where is the milk now?
Where is Joe?
Where was Joe before the office?

우선 첫 번째 질문에 답한다고 하자. 그러면 input은 다음과 같다.

$x=\text{"Where is the milk now?"}$

그리고 $O$ 모듈은 모든 메모리에 대해서 첫 번째 loop을 돌 것이다. 즉 전체 문장에 대해서 주어진 질문과 가장 유사한 문장을 찾아낸다. 그리고 이 경우에 결과를 통해 나온 memory는 다음과 같다.

$\mathbf{m}_{o_1}=\text{"Joe left the milk"}$

그리고 그 다음 loop을 돌 것이다. 주어진 input 그리고 memory slot $\mathbf{m}_{o_1}$을 사용해서 다음으로 match score가 높은 두 번째 문장을 찾는다.

$\mathbf{m}_{o_2}=\text{"Joe travelled to the office"}$

마지막으로 $R$ 모듈에서 $[x,\mathbf{m}{o_1},\mathbf{m}{o_2}]$를 사용해 최종 output을 만든다.

$r=\text{"office"}$

그리고 실험에서 score fucntion인 $s_O$와 $s_R$은 같은 형태의 함수를 사용했다.

$s(x,y)=\Phi_x(x)^TU^TU\Phi_y(y)$

여기서 $U$는 $n\times D$ matrix이다. $D$는 feature의 수를 뜻하고 $n$는 embedding 차원의 크기를 뜻한다. 그리고 $\Phi_x$ 와 $\Phi_y$ 는 raw한 형태의 text를 D 차원의 vector로 만들어주는 함수이다. $\Phi$ 함수의 가장 간단한 예는 bag of words 표현 방식을 사용하는 것이다. 이 실험에서 $D=3\vert W\vert$로 사용했다. 즉 각 문장을 3개의 표현방식을 사용해 vector로 만들었다. 하나는 $\Phi_x(.)$를 위한 representation이고, 하나는 $Phi_y$를 위한 representation이다. 그리고 마지막 하나는 이후의 장에서 설명한다. 이렇게 만든 이유는 input이 실제 처음 input text를 통해서 온 것인지, memory에서 온 것인지 구별하기 위해 각각 따로 representation을 했다. 마지막으로 $U$의 경우에도 $R$ 모듈과 $O$ 모듈 각각 다른 matrix를 사용했다.

Training

학습은 fully supervised setting을 통해 진행되었다. 즉 input과 response이 모두 주어지고 supporting sentence도 모두 labeling 되어있다. 따라서 score의 함수의 best choice를 알 수 있다. 그리고 학습 시 loss는 margin ranking loss함수를 사용하고 update는 stochastic gradient descent(SGD)를 사용했다. 우선 loss함수를 보면 다음과 같이 구성된다.

$\sum_{\bar{f}\ne \mathbf{m}_{o_1}}\max(0,\gamma-s_O(x,\mathbf{m}_{o_1})+s_O(x,\bar{f}))+$ $\sum_{\bar{f}'\ne \mathbf{m}_{o_2}}\max(0,\gamma-s_O([x,\mathbf{m}_{o_1}],\mathbf{m}_{o_2})+s_O([x,\mathbf{m}_{o_1}],\bar{f}))+$ $\sum_{\tilde{r}\ne r}\max(0,\gamma-s_R([x,\mathbf{m}_{o_1},\mathbf{m}_{o_2}],r)+s_R([x,\mathbf{m}_{o_1},\mathbf{m}_{o_2}],\tilde{r})$

Loss 함수를 자세히 알아보자. 우선 3개의 부분으로 나눠지는데 이는 k를 설정함에 따라 달라진다. 이 경우에는 위와 같이 $k=2$의 경우이고, $k$ 값이 커질수록 loss의 term의 개수가 많아질 것이다. 우선 하나씩 알아보자. 첫 번째 term의 경우 첫 번째 memory 선정에 따른 loss이고, 두 번째는 두 번째 memory 선정에 따른 loss함수이다. 마지막은 최종 결과인 response의 loss함수가 된다. 각 loss함수는 동일하게 margin ranking loss함수 형태인데, 이 loss함수의 의미는 학습시 선택한 memory(혹은 response)인 $\mathbf{m}_{o_1},\mathbf{m}_{o_2},r$ 과 선택하지 않은 것 중에서 score가 높은 memory(혹은 response)인 $\bar{f}, \bar{f}', \tilde{r}$ 과의 차이가 margin(위 식에서는 $\gamma$)보다 크도록 학습시키는 과정이다. 예를 들어 생각해보자. 위 식에서 우리가 선택한 memory와의 score와 다른 선택지 중 가장 높은 score와의 차이가 margin인 $\gamma$보다 작다면 loss는 양수값이 나올 것이다. 만약 margin보다 큰 경우에는 max를 통해 loss값이 0이 된다.

그리고 MemNN 구현 시 R은 RNN을 사용해서 구현했다. 따라서 이 경우에는 loss 함수의 마지막 term을 일반적인 language modeling에서 사용되는 일반적인 log likelihood를 사용했다.

Word Sequences as Input

위에서는 input을 문장으로 가정한 모델을 설명했다. 만약에 input이 단어라면 어떻게 해야 할까? 우선 word로 들어올 경우 가장 큰 문제점은 statement와 question이 구분되지 않는다는 점이다. 따라서 위의 경우와는 다른 접근법이 필요하다. 따라서 “segementation” 함수, 즉 단어들을 구분지어서 statement와 question들을 구분시켜주는 학습시킬 함수를 사용한다. 이 함수를 segementer라 한다. 이 segementer을 사용하면 sequence를 memory에 쓸 수 있고 그 이후는 위에 나온 모델과 동일하게 사용하면된다. 그리고 이 segementer는 다른 component들과 같이 embedding model 형태이다.

$seg(c)=W_{seg}^TU_S\Phi_{seg}(c)$

여기서 $W_{seg}$는 vector이다. 이 vector의 역할은 embedding 된 값을 linear clasification 해주는 역할이다. 그리고 $c$는 input seqeunce로 vector 형태이다. 즉 각 단어들이 bag of words 형태로 들어온다. 따라서 이 함수의 결과값이 특정 margin $\gamma$보다 큰지 안큰지에 따라서 sequence가 하나의 segment인지 아닌지를 판단한다. 즉 아래와 같이 구분된다.

$c = \begin{cases} \text{segment}&\text{, if }seg(c)>\gamma\\ \text{not segment} &\text{, otherwise}& \end{cases}$

Result & Conclusion

실험결과에 대해서는 소개하지 않는다. 논문을 참고하길 바란다. 그리고 해당 모델은 하나의 Attention으로 볼 수 있는데, Hard attention으로 분류된다. 이후 다음 모델은 해당 모델보다 좀더 unsupervised한 성격의 모델로 Soft attention 성격의 모델이다. Memory를 사용하는 모델로 기존 RNN 혹은 LSTM 보다 성능이 좋다는 것을 확인할 수 있다.

오역 및 잘못된 내용이 있을 수 있습니다. 잘못된 부분 혹은 이해가 잘 안되는 부분은 댓글 혹은 메일로 말씀해주시면 감사하겠습니다!

ConvS2S: Convolutional Sequence to Sequence Learning

2018-09-11T06:47:35+00:00

이번에 소개할 논문은 Facebook에서 발표한 ConvS2S라 불리는 Convolutional Sequence to Sequence Learning이다. 이름부터 알 수 있듯이 sequence to sequence 모델을 convolutional neural network를 사용해서 만든 모델이다. 기존의 sequence to sequence 모델들은 대부분 RNN을 기반으로 나왔는데, CNN을 사용해서 sequence를 다루면서 높은 성능을 보여준 모델이라 많은 의미가 있다. RNN 대신 CNN으로 어떻게 모델을 구성하는지, 또 RNN대신 CNN을 사용하면 어떤 장점이 있는지 알아보자.

Introduction

Sequence to sequence learning은 기계번역, 음성인식, text 요약 등 많은 분야에서 성공적인 결과를 보여줬다. 이러한 모델 구성중 대부분이 encoder에서 bi-directional RNN을 사용하고 decoder에서도 RNN을 사용했다.

그에 반해 Convolutional neural network는 sequence를 다루는 모델에서는 별로 사용하지 않았다. sequence 모델에 CNN을 적용할 때를 RNN을 적용할 때와 비교해 보자. CNN을 적용하면 고정된 크기의 문맥만을 얻을 수 있다. 즉 우리가 정의한 kernel size로만 문맥을 파악하게 할 수 있는데, 다행이도 CNN은 몇개의 layer를 추가함으로써 context size를 늘리는 것이 쉽다. 따라서 모델의 maximum length of dependencies를 제어하기가 쉽다. 또한 RNN은 이전 step의 값이 있어야 계산을 할 수 있는데 반해 CNN은 그럴 필요가 없기 때문에 병렬화가 쉽다는 장점이 있다.

Multi-layer CNN을 생각해보자. 층층이 쌓여서 hierarchical한 구조를 만드는데 이는 lower layer에서는 단어 주변의 문맥을 파악하고 higher layer로 가면 먼 거리의 단어도 파악할 수 있게 된다.

그렇다면 시간을 고려해보자. CNN의 경우 n개의 단어를 문맥으로 파악하려면 드는 시간은 $O(\frac{n}{k})$이다. RNN의 경우를 생각해보면 linear하기 때문에 시간은 $O(n)$이 된다.

해당 논문에서는 sequence를 다루는 모델로 전체가 convolutional neural network로 구성된 모델을 소개한다. 다음의 세가지를 사용해서 모델을 구성할 것이다.

Gated linear units (Dauphin et al., 2016)
residual connections (He et al., 2015)
attention

소개한 모델의 평가는 두가지 task로 진행한다. Machine translation과 Text summerization으로 진행한다.

Recurrent Sequence to Sequence Learning

기존의 recurrent한 sequence to sequence 모델을 생각해보자. input에 대해서 RNN을 통해 representation을 계산한다. 여기까지가 encoder이고, decoder에서는 구한 representation을 가지고 다시 RNN 모델을 사용해 output을 만든다. 그리고 decoder에서는 conditional input을 사용하기도 한다. attention을 도입한 모델에서는 conditional input으로 representation을 가중 평균한 값으로 사용한다.

그리고 가장 흔히 쓰이는 RNN 모델은 LSTM과 GRU이다. 둘다 Elman RNN을 응용해서 나온 모델로 long-term dependency를 잡기 위해 만들어 졌다. 그리고 최근에 가장 많이 쓰이는 모델은 bi-directional encoder 이다. RNN을 input에 대해 양방향으로 두개의 RNN을 만들어서 사용하는 것이다. 그리고 추가적인 기법으로는 shortcut과 residual connection을 많이 사용한다.

A Convolutional Architecture

sequence to seqeunce modeling을 fully convolutional architecture를 살펴보자.

Position Embeddings

우선 가장 먼저 input $\mathbf{x}$을 embedding vector $\mathbf{w}$로 만든다. 그리고 embedding한 dimension과 똑같이 각 token의 절대적인 위치에 대한 embedding vector $\mathbf{p}$를 만들어서 두 vector를 더해서 representation vector $\mathbf{e}$를 만든다.

$\begin{align*} &\mathbf{x} = (x_1,...,x_m)\\ &\mathbf{w} = (w_1,...,w_m)\\ &\mathbf{p} = (p_1,...,p_m)\\ &\mathbf{e} = (w_1+p_1, ...,w_m+p_m) \end{align*}$

그리고 이러한 position embedding 기법은 decoder에 의해 만들어진 ouput 값에서도 사용된다.

Convolutional Block Structure

encoder와 docoder 모두 simple block 구조를 비슷하게 사용한다. 이 block은 고정된 개수의 input을 연산한다. 여기서 $l$-th block을 decoder에서는 $\mathbf{h}^l=(h_1^l,…,h_m^l)$이라 표현하고 encoder에서는 $\mathbf{z}^l=(z_1^l,…,z_m^l)$라 표현한다. 그리고 해당 논문에서 block과 layer는 같은 의미로 사용된다.

각각의 block의 구성은 1d convolution + non-linearity로 구성된다. 하나의 예를 보자. decoder에서 하나의 block이 있다고 하자. 그리고 이 block의 kernel size가 5라고 하면 convolution 하나의 단일 결과인 $h_i^1$는 k개의 단어에 대한 정보를 포함하고 있다. 몇개의 block들을 위에 쌓음으로써 정보를 포함하는 단어의 개수를 늘릴 수 있다.

예를 들어 kernel size가 5인 6개의 blcok을 쌓았다고 생각하면 총 25개의 단어의 정보를 포함하고 있다.

그리고 각 convolution의 kernel의 파라미터는 $\mathbf{W}\in\mathbb{R}^{2d\times kd}$와 $\mathbf{b}_w\in\mathbb{R}^{2d}$이다. 위 파라미터는 단어 하나당 $d$-dimension vector인 단어 k개를 포함하는 matrix인 $\mathbf{X}\in \mathbb{R}^{k\times d}$를 input으로 계산된다.

kernel에 적용시킨 결과 output을 $\mathbf{Y}\in\mathbb{R}^{2d}$라 부른다. 이 vecotr의 dimension은 input의 dimension의 2배가 되었는데 이는 gated linear unit을 적용시키기 위함이다.

$\mathbf{Y}=\text{conv}(\mathbf{X}\mathbf{W})+\mathbf{b}$ $\text{where}~ \mathbf{X} = [\mathbf{e}_i,...,\mathbf{e}_{i+k-1}]\text{, with }\mathbf{e}_i = \mathbf{w}_i + \mathbf{p}_i$

그리고 이 모델에서는 convolution 결과에 non-linearity로 gated linear unit(GLU: Dauphin et al., 2016)를 사용했다. convolution을 output의 dimension을 생각해보면 input과는달리 2d였다. 이는 GLU를 사용하기위해 dimension을 2배로 만들어 준것인데, dimension이 2배가된 output vector를 2개로 나눠서(A,B) GLU에 적용시킨다. GLU의 식은 다음과 같다.

$v([A,B]) = A\otimes\sigma(B)$

여기서 $A, B$는 d차원의 vector가 된다. 그리고 $\otimes$는 element-wise multiplication이다. GLU를 통해 다시 output은 resize되어서 dimension이 input과 같아진다.

GLU에 대해서 좀 더 생각해보자. input으로 A,B 두 벡터가 들어가게 되는데, 하나는 값 그대로 들어가고 또 다른 하나는 sigmoid를 적용시켜서 들어간다. sigmoid를 적용시킨 값은 A를 문맥에 적용시키기 위해서 사용한 것이다.

개인적인 생각 GLU에서 하나의 vector를 반으로 나눠서 적용시키는데 이는 거의 유사한 값이라고 생각하자. 이때 하나는 그 값 그대로 넣고 나머지 하나는 sigmoid를 적용시킨다. 따라서 한 벡터는 값을 의미하고 한 벡터는 그에 대한 확률 값이라 생각할 수 있다. 즉 input을 적용시키지 않고 비율을 각각 곱해준뒤 적용시킨다고 생각할 수 있다.

해당 논문에서는 GLU에서 sigmoid를 사용했는데, tanh를 사용하는 경우도 있다. 하지만 Dauphin의 말을 인용하면 language modeling에서는 tanh 보다 sigmoid를 적용하는 것이 성능이 좋다고 한다.

다음으로는 deep한 convolutional network를 만들기 위해서 residual connection을 사용했다. residual connection을 사용한 수식은 다음과 같다.

$h_i^l = v(\mathbf{W}^l[h_{i-k/2}^{l-1},...,h_{i+k/2}^{l-1}]+b_w^l)+h_i^{l-1}$

수식에서 마지막 더해진 항이 residual connection 값이다.

encoder network에서 output값이 input값과 동일하게 하기 위해서 sequence의 양끝에 padding을 추가한다. 즉, 양 끝에 k-1 개의 0값을 추가한다. 그리고 output에서 마지막 k개의 원소를 제거해서 사용한다.

마지막으로 decoder의 output인 $h_i^L$에 weight를 곱한 후 bias를 더한 값에 softmax를 취해서 다음 token 값인 $y_{i+1}$을 얻어낸다.

$p(y_{i+1}\vert y_1,...,y_i,\mathbf{x})=\text{softmax}(W_oh_i^L+b_o)\in \mathbb{R}^T$

Multi-step Attention

해당 논문에서 decoder layer에 separate attention mechanism을 적용시켰다. attention 계산을 위해서 현재 decoder state vector에 이전 target element의 embedding값($g_i$)을 더해준다.

$d_i^l=W_d^lh_i^l+b_d^l+g_i$

decoder layer $l$의 attention 값인 $a_{ij}^l$은 현재 state $i$에 대한 source 원소인 $j$의 attention 값을 나타낸다. 계산은 decoder의 state summary 값인 $d_i^l$과 encoder의 output값인 $z_j^u$를 dot-product한 값을 softmax 취해주면 된다.

$a^l_{ij}=\frac{\exp(d_i^l\cdot z_j^u)}{\sum^m_{t=1}\exp(d_i^l\cdot z_t^u)}$

그리고 이 attention 값을 사용해서 decoder에 사용될 conditional input $c_i^j$를 계산한다. 이 때 attention 값을 encoder의 output 값에 가중평균하는데 encoder의 output만 사용하는 것이 아니라 input값이 embedding 값도 더해줘서 가중평균한다.

$c_i^l=\sum^m_{j=1}a_{ij}^l(z_j^u+e_j)$

이 attention 구조는 기존의 RNN에서 사용한 attention 과는 $z$뿐만아니라 embedding 값인 $e$를 사용했다는 점이 다르다. 여기서 사용한 attention을 생각해보면 encoder를 통해서 나온 값인 $z$를 key로 해석할 수 있고, 각 input의 embedding 값인 $e$를 value로 해석할 수 있다.

또 다른 해석은 $z$는 context에 대한 정보도 포함을 하고 있고, $e$는 하나의 token에 대한 정보를 담고 있으므로 두 정보를 모두 사용하는 것이다.

계산된 conditional input $c$는 간단하게 decoder layer의 output $h_i^l$에 더해서 사용한다.

attention은 multi hop구조로 적용된다. 즉 attention을 통해 나온 결과를 바로 결과로 만든는 것이 아니라 결과를 다시 또 attention을 거치게 하는 구조이다. 이러한 구조는 첫 attention을 통해 유용한 정보를 결정하고 이제 유용한 정보만을 사용해서 다시 attention을 적용하는 구조로 생각할 수 있다.

이때까지 나온 구조를 그림을 통해서 이해해보자. 우선 전체 그림은 다음과 같다.

그림의 윗 부분이 encoder이고 아랫 부분이 decoder이다. 중간의 matrix는 attention 값들을 의미한다. encoder의 값들과 decoder의 값들을 사용해서 attention 값을 을 계산한다. encoder의 우측부분은 embedding vector 와 encoder output을 더하는 것을 의미한다. 이 값을 attention값과 가중 평균 해준다.

이제 encoder와 decoder를 나눠서 살펴보자. 이제부터의 그림은 stanford의 seminar slide에서 나온 그림이다.

먼저 encoder 먼저 살펴보자.

convolution을 계산한 후 2개의 벡터로 나눠서 gated linear unit이 계산된다. 그리고 residual connection으로 연결된 모습을 볼 수 있다. 위 그림의 가장 상단의 결과가 $z$가 될 것이다.

이제 decoder의 그림을 보자.

우선 encoder와 마찬가지로 convolution이 계산되고 gated linear unit까지 계산되는 부분은 동일하다. 이제 그 결과를 encoder값과 같이 attention 값을 사용한다. 그리고 그 결과를 이전의 결과 값과 더해주고 마지막으로 residual connection까지 계산을 해주면 최종 출력이 나오는 모습이다.

하지만 해당 논문에서는 이런 single attention이 아닌 multi hop 구조를 사용했다고 했는데 이를 그림으로 표현하면 다음과 같을 것이다.

attention 까지 계산한 결과가 다시 input으로 들어가서 다시한번 attention을 계산하는 형태이다. 전체적인 multi hop 구조는 아래의 그림을 보면 좀 더 이해가 쉬울 것이다.

전체적인 구조에 대한 설명은 여기까지이다. 이제 Normalization 방법과 initialize한 방법에 대해서 알아보자.

Normalization Strategy

해당 논문에서는 Batch Normalization은 사용하지 않고 weight nomalization을 사용했다. 논문의 말에 따르면 network의 전체적인 varience가 크게 변하지 않도록 initialize와 normalize에 신경을 썻다고 한다.

특히 residual block의 output과 attention을 scaling 해서 전체적인 variance를 크게 변하지 않도록 했다. residual block에는 $\sqrt{0.5}$를 곱해서 varience를 절반으로 줄였다.

그리고 attention 값인 conditional input $c_i^l$에는 전체 attention score가 균등 분포를 따른다고 가정하고 원래 크기에 맞춰주기 위해 $m\sqrt{1/m}$을 곱해서 scale up 했다.

그리고 multiple attention을 사용한 convolutional decoder에는 gradient 값도 사용한 attention 수만큼 scaling 했다.

Initialization

Residual connection과 같이 다른 layer의 값을 어떤 layer에 더하는 모델에는 초기값 설정이 매우 중요하다. 사용한 초기값 설정은 대부분 정규 분포를 따르도록 했으며, 평균 0 에 표준편차를 weight에 맞게끔 설정해줬다.

Experiment

Datasets

데이터셋은 간단하게 소개만 한다. 다음의 데이터셋들을 사용해서 실험을 했다.

WMT’16 English-Romanian
WMT’14 English-German
WMT’14 English-French
그 외 몇가지 corpus

Model Parameters and Optimization

Parameter와 사용한 optimization에 대한 정보는 다음과 같다.

Encoder 와 decoder에 512개의 hidden unit 사용.
모든 embedding은 512 dimension
Nesterov’s accelerated gradient 방법을 사용해서 학습
- 하이퍼 파라미터인 모멘텀 값은 0.99로 하고 norm이 0.1을 넘지 않도록 만들었다.
학습률은 0.25로 설정했다.
- 학습률은 학습이 경과하면서 계속 감소하도록 설정하고 그 값이 $10^{-4}$보다 작아지는 Epoch에서 학습을 멈추도록 설정
64 크기의 mini-batch 사용
가장 긴 sentnece의 길이는 GPU memory에 맞게 설정(64 mini batch에서 메모리가 허용하는 가장 긴 길이 사용)
gradient는 mini-batch의 padding 값이 아닌 값들의 개수로 normalize함
convolutional block의 input과 embedding에 dropout사용

Result

결과도 간단히 보고 넘어가자.

Conclusion

다른 모델들에 비해 상대적으로 최근에 나온 모델이고, 모델을 발표한 facebook에서 소스코드 또한 공개를 해서 성능 높은 모델을 접근성 높게 사용할 수 있다는 장점이 있다. 그리고 기존의 RNN이 대부분이였던 Sequence to sequence 모델에서 CNN만을 사용해서도 다른 모델보다 높은 성과를 보여줬다는 것은 새로운 모델도 계속해서 나올 것이라는 것을 예상해 볼 수 있다.

그리고 무었보다 이 모델의 sequence에 적용했을 때의 장점은 다른 RNN계열의 모델들 보다 병렬화가 쉽기 때문에 속도가 매우 빠르다는 것이 큰 장점이다.

오역 및 잘못된 내용이 있을 수 있습니다. 잘못된 부분 혹은 이해가 잘 안되는 부분은 댓글 혹은 메일로 말씀해주시면 감사하겠습니다!

Transformer: Attention is all you need

2018-09-08T06:47:35+00:00

이번에 리뷰할 논문은 Google에서 발표한 Attention is all you need이다. 논문 이름부터 어떤 내용을 다룰지 짐작가게 하는데, 기존의 attention에 대해서 생각해보면 sequence to sequence 모델에서 혹은 convolutional neural network 모델에서 부가적으로 attention mechanism을 적용시켰다고 볼 수 있는데, 이 논문에서는 attention만으로 모든 모델을 만들었다는 점이 흥미롭다.

자세한 설명 이전에 간단히 설명하자면 기존의 모델들 처럼 RNN 혹은 CNN을 사용하지 않고 attention만 사용해서 연산량이 매우 줄었다. 그럼에도 불구하고 성능도 매우 높게 나오는 모델이다. Transfomer라고도 불리는데 논문을 보면서 어떻게 구성되어 있는지 자세히 알아보도록 하자.

Introduction

RNN 모델들이 주로 기계 번역 혹은 language modeling 등 sequence를 다루기 위한 모델로 많이 사용되고 있다. 하지만 이런 RNN을 활용한 모델을 문장이 길어질수록 성능이 떨어지고 memory의 제약으로 batch에도 제한이 생길 수 있다는 단점이있다. 또한 단순한 sequence to sequence 모델은 sequnece의 alignment를 해결하지 못한 문제가 아직 남아있다.

attention mechanism을 통해 위에서 언급했던 RNN 모델의 문제점을 어느정도 해결했지만 결국 대부분의 모델은 attention이 RNN과 함께 사용되는 용도로만 사용되었다.

해당 논문에서는 Transformer 라 불리는 모델을 소개한다. 다른 CNN 혹은 RNN 모델 없이 단순히 attention mechanism만으로 모델을 구성했으며 학습시간이 매우 빠르다는 장점이 있다.

Model Architecture

대부분의 sequence를 다루는 모델들은 encoder-decoder 구조로 되어있다. 여기서 encoder는 input sequence를 continuous한 representations로 바꾸고 decoder는 이 representation을 통해 output을 만들어낸다.

Transformer의 전체적인 architecture는 stacked self-attention(intra-attention)과 point-wise fc layer들을 사용해서 구성되어 있다. 아래 그림이 전체 architecture를 나타낸다. 그림에서 왼쪽이 encoder이고 오른쪽이 decoder이다.

이제 모델 하나하나 자세히 알아보도록 하자.

Encoder & Decoder

Encoder

Encoder는 동일한 layer가 N개 반복되는 형태이다. 이 논문에서는 6번 반복했다. 그리고 각 layer는 두개의 sub-layer로 구성된다. 첫 sub-layer는 multi-head self-attention mechanism이고 두번쨰는 간단한 point-wise fc-layer이다. 그리고 모델 전체적으로 각 sub-layer에 residual connection을 사용했다. 그리고 residual 값을 더한 뒤에 layer 값을 Nomalize한다. 즉 각 sub-layer는 결과에 대해 residual 값을 더하고 그 값을 nomalize한 값이 output으로 나오게 된다. 그리고 모델 전체적으로 residual 계산을 쉽게하기 위해서 output의 dimension은 모두 512로 맞췄다.

Decoder

Decoder도 encoder와 마찬가지로 동일한 layer가 N개 반복되는 형태이다. 그리고 이 논문에서는 decoder도 6번 반복했다. 그러나 반복되는 layer가 encoder와는 다른 구조이다. 총 3개의 sub-layer로 구성되어 있는데, 2개는 기존의 encoder의 sub-layer와 동일하고 나머지 하나는 encoder의 ouput에 대해 multi-head attention을 계산하는 sub-layer가 추가되었다. 그림으로 보면 오른쪽의 가운데 sub-layer이다.

Decoder에서도 residual connection을 사용했다. residual 값을 더한 후 동일하게 layer nomalize를 해준다. 그리고 self-attetion을 encoder와는 약간 다르게 수정을 했는데, masking을 추가했다. self-attention시 현재 위치보다 뒤에 있는 단어는 attend 못하도록 masking을 추가해준 것이다.

Attention

이 모델에서 사용한 attention은 총 2가지 종류이다. 하나는 Scaled dot-product attention이고 나머지 하나는 Multi-head attention이다.

Scaled dot-product attention

해당 attention의 input은 3가지다. $d_k$ dimension을 가지는 queries와 keys, 그리고 $d_v$ dimension을 가지는 values로 구성된다. 우선 하나의 query에 대해 모든 key들과 dot product를 한 뒤 각 값을 $\sqrt{d_k}$ 로 나눠준다. 그리고 softmax함수를 씌운 후 마지막으로 value를 곱하면 attention 연산이 끝난다.

실제로 계산할때는 query, key, value를 vector하나하나 계산하는 것이 아니라 여러개를 matrix로 만들어 계산한다. 수식은 다음과 같다.

$\text{Attention}(Q, K, V) =\text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$

추가적인 설명 우선 query와 key, value에 대해서 설명하면 query가 어떤 단어와 관련되어 있는지 찾기 위해서 모든 key들과 연산한다. 여기서 실제 연산을 보면 query와 key를 dot-product한뒤 softmax를 취하는데, 의미하는 것은 하나의 query가 모든 key들과 연관성을 계산한뒤 그 값들을 확률 값으로 만들어 주는 것이다. 따라서 query가 어떤 key와 높은 확률로 연관성을 가지는지 알게 되는 것이다. 이제 구한 확률값을 value에 곱해서 value에 대해 scaling한다고 생각하면된다.

추가적인 설명 key와 value는 사실상 같은 단어를 의미한다. 하지만 두개로 나눈 이유는 key값을 위한 vector와 value를 위한 vector를 따로 만들어서 사용한다. key를 통해서는 각 단어와 연관성의 확률을 계산하고 value는 그 확률을 사용해서 attention 값을 계산하는 용도이다.

보통 흔히 사용되는 attention 함수는 additive attention과 dot-product(multiplicative) attention 두가지다. 후자의 경우가 현재 사용하고 있는 attention과 거의 유사하다. 다른점은 $\frac{1}{\sqrt{d_k}}$로 scailing을 하지 않았다는 점이다. 그리고 dot-product attention과 additive attention을 비교하면 dot-product attention이 속도측면에서 앞선다. 복잡도는 비슷한데 속도가 앞서는 이유는 matrix multiplication에 대한 최적화된 구현이 많이 있기 때문이다.

그리고 앞서 설명하지 않았던 것이 하나 있다. rescaling을 하는 부분인데, 만약 dimension의 루트값으로 나눠주지 않는다면 어떤 일이 생기는지 생각해보자. vector의 길이가 길어질수록, 즉 dimension이 커질수록 자연스럽게 dot-product값은 점점 더 커질 것이다. 그러나 이후에 softmax함수가 있기 때문에 back-propagation 과정에서도 미분값이 조금만 넘어오게 되서 상대적으로 학습이 느려지거나 학습이 잘안되는 상황이 발생할 수 있다. 따라서 dimension이 큰 경우를 대비해 dimension의 루트값으로 나눠준다.

Multi-head attention

기존의 attention은 전체 dimension에 대해서 하나의 attention만 적용시켰다. 여기서 사용한 Multi-head attention이란 전체 dimension에 대해서 한번 attention을 적용하는 것이 아니라 전체 dimension을 h로 나눠서 attention을 $h$번 적용시키는 방법이다.

각 query, key, value의 vector는 linearly하게 $h$개로 project 된다. 이후 각각 나눠서 attention을 시킨 후 만들어진 $h$개의 vector를 concat하면 된다. 마지막으로 vector의 dimension을 $d_{\text{model}}$ 로 다시 맞춰주도록 matrix를 곱하면 끝난다. Multi-head attention을 수식으로 표현하면 다음과 같다.

$\begin{matrix} \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1,...,\text{head}_h)W^O\\ \text{where}~\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K,VW_i^V) \end{matrix}$

각 파라미터의 shape은 다음과 같다.

$W_i^Q,~W_i^K\in\mathbb{R}^{d_{\text{model}}\times d_k}, W_i^V \in\mathbb{R}^{d_{\text{model}}\times d_k}, W^O \in \mathbb{R}^{hd_v\times d_{\text{model}}}$

해당 논문에서는 $h=8$ 즉 8개의 head를 사용했다. 따라서 각 vector들의 dimension은 다음과 같이 8로 나눠진다.

$d_k=d_v=d_{\text{model}}/h = 64$

$h$번 계산했지만 각 head들이 dimension이 줄었기 때문에 전체 연산량은 비슷하다.

Applications of Attention in our Model

Transformer에서 multi-head attention을 다음과 같은 방법으로 사용했다.

“encoder-decoder attention” layer에서 query들은 이전 decoder layer에서 온다. 그리고 encoder에서 온 key와 value를 사용한다. 따라서 decoder의 모든 위치의 token은 input sequence의 어느 곳이든 attend할 수 있게 된다.
encoder는 self-attention layer를 가진다. 모든 key, value, query는 같은 sequence에서 온다. 정확히는 이전 layer의 output에서 온다. 따라서 encoder는 이전 layer의 전체 위치를 attend할 수 있다.
decoder의 self-attention layer도 이전 layer의 모든 position을 attend 할 수 있는데, 정확히는 자신의 position이전의 position까지만 attend 할 수 있다. 직관적으로 이해하면 sequence에서 앞의 정보만을 참고할 수 있게 한 것이다. 이러한 목적을 scaled dot-product를 masking 함으로써 구현했다.

Position-wise Feed-Forward Networks

attention sub-layer에 이어서 fully connected feed-forward network 거치게 되는데 이 network는 두개의 linear transformation으로 구성되어 있고 두 transformation 사이에 ReLU 함수를 사용한다.

$\text{FFN}(x)=\max(0, xW_1+b_1)W_2+b_2$

Embeddings and Softmax

다른 sequence 모델과 유사하게 embedding vector를 사용한다. 입력 token을 linear transformation 해서 $d_{\text{model}}$ dimension vector로 바꿔주고 softmax로 나온 decoder의 결과 값을 predicted next-token으로 다시 linear transformation해서 바꿔준다. 모델 전체를 보면 3번 embedding 과정(역 embedding 포함)이 있는데, 이 때 linear transofrmation에 사용되는 weight matrix는 다 같은 matrix를 사용한다. 즉 2개의 embedding layer에서의 linear transformation과 softmax 다음의 linear transormation에서 같은 matrix를 사용하는 것이다.

Positional Encoding

해당 모델에서는 recurrence나 convolution을 전혀 사용하지 않았기 떄문에, 추가적으로 위치 정보를 넣어줘야 한다. 따라서 “positional encoding”을 사용해서 input embedding에 위치 정보를 넣어준다. 각 위치에 대해서 embedding과 동일한 dimension을 가지도록 encoding을 해준 뒤 그 값을 embedding값과 더해서 사용한다.

positional encoding에는 여러 방법이 있지만 여기서는 sin, cos 함수를 사용해서 구현한다. 각 위치 $pos$와 dimension $i$에 대한 positional encoding값은 다음과 같이 구한다.

$\begin{matrix} PE_{(pos,2i)}=\sin(pos/10000^{2i/d_{\text{model}}})\\ PE_{(pos,2i+1)}=\cos(pos/10000^{2i/d_{\text{model}}}) \end{matrix}$

Why self-attention

이 모델에서 recurrent 나 convolution을 사용하지 않고 self-attention만을 사용한 이유에 대해서 알아보자. 3가지 이유로 self-attention을 선택했다.

레이어당 전체 연산량이 줄어든다.
병렬화가 가능한 연산이 늘어난다.
long-range의 term들의 dependency도 잘 학습할 수 있게 된다.

그리고 위의 3가지 외에 또 다른 이유는 attention을 사용하면 모델 자체의 동작을 해석하기 쉬워진다는(interpretable) 장점 때문이다. attention 하나의 동작 뿐만 아니라 multi-head의 동작 또한 어떻게 동작하는지 이해하기 쉽다는 장점이 있다. 아래의 그림을 보면 어떻게 attention mechanism이 적용되는지 쉽게 이해할 수 있다.

Training

학습에 사용된 것들을 하나씩 알아보자.

Training data and batching

학습에 사용된 데이터는 WMT 2014 English-German 데이터 셋이다. 총 450만개의 영어-독일어 문장 쌍이 있다. 그리고 WMT 2014 English-French 데이터 셋도 사용했다. 총 360만개의 문장 쌍이 있다. 학습시 대략 25000개의 token을 포함하는 문장 쌍을 하나의 배치로 사용했다.

Optimizer

학습에 사용된 optimizer는 Adam을 사용했다. 하이퍼 파라미터로는 $\beta_1=0.9$, $\beta_2=0.98$, $\epsilon=10^{-9}$를 사용했다. 학습률(learning rate)의 경우 학습 경과에 따라서 변화하도록 만들었다. 아래의 공식으로 학습률을 계산해서 적용했다.

$lrate=d_{\text{model}}^{-0.5}\cdot\min(\text{step_num}^{-0.5},\text{step_num}\cdot \text{warmup_steps}^{-1.5})$

여기서 warmup_step의 값으로는 4000을 사용했다.

Regularization

학습 시 정규화를 위해서는 세가지 방법을 사용했다.

Residual dropout
Attention dropout
label smoothing

여기서 dropout 값은 0.1로 했고, label smoothing 값도 0.1로 설정했다.

Conclusion

번역에서 Tansformer는 다른 모델들 보다 훨씬 빠르게 학습했다. 그리고 빠른 속도에도 성능에서도 이전의 모델들보다 좋은 성능을 보여줬다.

Recurrent, convolution을 전혀 사용하지 않고 attention만 사용해서 만든 모델임에도 좋은 성능을 보여줬다. 우선 이 모델이 크게 의미하는 바는 빠른 학습속도를 보여준 것이다. 따라서 앞으로도 번역 뿐만 아니라 이미지 등 큰 input을 가지는 문제에도 적용할 수 있을 것이다.

오역 및 잘못된 내용이 있을 수 있습니다. 잘못된 부분 혹은 이해가 잘 안되는 부분은 댓글 혹은 메일로 말씀해주시면 감사하겠습니다!

CS20(TensorFlow) Lecture Note (12): Machine Translation, Seqeunce-to-sequence and Attention

2018-09-07T04:47:35+00:00

스탠포드의 TensorFlow 강의인 cs20 강의의 lecture note를 정리한 글입니다. 강의는 오픈되지 않아서 Lecture note, slide 위주로 정리된 글임을 참고 해주시길 바랍니다. 강의의 자세한 Syllabus 및 자료들을 아래 링크를 참고해 주세요.

CS20: TensorFlow for Deep Learning Research

Post list

12. Machine Translation, Seqeunce-to-sequence and Attention

이번 강의에서 알아볼 내용은 크게 다음과같이 세가지로 나눌 수 있다.

새로운 task: Machine Translation
새로운 neural netwrok architecture: Sequence to sequence
새로운 neural technique: Attention

위의 세가지는 각각 별개의 내용이 아니고 깊게 연관되어있다. Machine Translation을 위한 주로 사용하는 architecture가 seuqeunce to sequence이고, seqeunce to sequence를 사용할 때 같이 주로 사용하는 것이 attention 기술이다. 이제 하나씩 알아보도록 하자.

Machine Translation

Machine translation이란 말 그대로 기계를 통해 번역을 하는 문제다. 정확히 말하면 어떤 언어의 input sentence를 다른 언어의 output sentence로 만드는 task이다.

$\begin{matrix} \text{x: L'homme est né libre, et partout il est dans les fers}\\ \downarrow\\ \text{y: Man is born free, but everywhere he is in chains } \end{matrix}$

기계번역은 시대에 따라서 번역을 하는 방법이 계속해서 바껴왔는데, 어떤 방식으로 진행해 왔는지 알아보자.

1950년대

Machine Translation이 처음 나온것이 1950년이다. 시대적으로 기계번역이 나온 역사적 이유가있다. 이 시기는 냉전 시기로 소련과 미국은 항상 서로의 통신이나 기밀 문서들을 자동으로 번역해서 해석하기를 원했는데, 이를 위해 Machine Translation이 처음 도입된 것이다. 따라서 이당시의 machine translation은 주로 영어, 러시아어 번역이 대부분이였다.

그리고 이 당시의 번역은 주로 rule-based 방식이였다. 즉 두 개의 언어의 사전을 통해 각 단어가 대응되는 것을 찾아서 번역하는 가장 단순한 방식이다.

1990 ~ 2000년대 초반

기존의 rule-based 방식이 아닌 data를 통해서 번역하는 방식이 처음으로 사용되었다. 이때의 방식을 Statistical Machine Translation이라 부르는데, 데이터를 통해 확률 분포를 학습하는 방법이다.

데이터를 통해 확률을 가장 높이는 방법으로 번역한다. 즉 특정 언어 input sentnece $x$에 대해서 또 다른 언어 output sentence인 $y$로 번역할 때 다음의 확률이 가장 높은 sentence를 선택하게 된다.

$\arg\max_y P(x\vert y)P(y)$

그리고 실제로 사용할 때는 위의 수식을 bayes theorem을 사용해 다음과 같이 번형해서 두개의 부분을 계산하는 방식으로 수행한다.

$\propto\arg\max_yP(x\vert y)P(y)$

위 식을 보면 $P(x\vert y)$와 $P(y)$로 두개의 두분으로 나뉘는데, 앞부분은 Translation Model이라 부르고 parallel 데이터를 통해서 확률을 계산하고 뒷부분은 Language Model으로 monolingual 데이터를 통해서 계산한다.

여기서 parallel 데이터란, 문장들이 두개의 언어 모두로 표현되어 있는 데이터이다. 따라서 한 문장에 대해 두가지 언어표현을 통해 한 언어에 대한 다른 언어로 바꿧을 때의 확률을 계산할 수 있게 한다. 그리고 monolingual 데이터란 하나의 언어만 있는 데이터로 이 데이터를 통해 언어의 특성을 확률값으로 계산한다.

Statistical machine translation(SMT)를 통해 기존의 rule-based 방식에 비해 정확도를 매우 높였지만 그럼에도 불구하고 alignment 문제가 아직 남아있다. alignment 문제란 번역에서 두개의 언어는 각각 특성이 달라서 단어들의 순서나 품사의 순서가 다른데 이러한 부분을 SMT로는 이런 부분까지 파악하기 어렵다는 점이다. 아래는 alignment가 제대로 이뤄지지 않은 번역을 나타낸다.

$\begin{matrix} \text{x: i go to school}\\ \downarrow\\ \text{y: 나는 간다 학교에} \end{matrix}$

위와 같은 alignment 문제가 있음에도 불구하고 SMT는 불과 몇 년전까지만 하더라도 대부분 사용하는 방법이였고, 많은 연구가 이뤄졌다. SMT의 특징을 정리하면 다음과 같다.

좋은 성능을 내는 SMT system은 매우 복잡한 구조이다.
각 system은 각 부분부분으로 나눠서 sub-system들이 모여있는 형태다.
많은 feature engineering이 필요하다.
추가적인 많은 자료를 필요로 한다.
사람의 손이 빠지고는 좋은 성능을 기대하기 어렵다.

2014년 ~

2014년 Sequence to sequence라는 모델을 통해 Nerual Machine Translation이 도입되었다. 기존의 SMT모델에 비해 매우 간단함에도 불구하고 매우 높은 성능을 보여줬다. 그리고 현재의 대부분의 Machine translation은 NMT를 사용한다.

세계에서 가장 많이 사용하는 번역기인 google 번역기도 2014년 sequence to sequence가 나온 2년뒤인 2016년 기존의 Statistical machine translation에서 Neural machine translation으로 바꾸었다. 기존의 SMT가 오랜 기간에 거쳐서 실제 사용할 수 있게된것에 비해 NMT의 경우에는 2년만에 바로 사용하는 것을 보면 성능이 좋다는 것을 의미한다고 볼 수 있다.

그렇다면 NMT의 장점을 정리해서 보자. SMT에 비해 NMT는 다음의 장점이 있다.

높은 성능
- 더욱 사람이 한 것 같은 번역
- 문맥 이해를 잘한다
하나의 neural network만으로도 사용할 수 있다.
사람이 직접 engineering을 많이 하지 않아도 된다.

많은 장점이 있지만, 무조건 좋은 것은 아니다 NMT에도 다음과 같은 단점이 존재한다.

해석하기 어렵다. 즉, 정확하게 어떻게 번역되는지 확인이 어려워 debug또한 어렵다.
위와 비슷한 이유로 제어하기 어렵다는 단점이 있다.

따라서 무조건 NMT만 사용하는 것이 아니라 SMT도 결합해 사용하거나 SMT를 아직 사용하기도 한다. 그리고 NMT를 사용할 때 어려운 점은 다음과 같다.

Out-of-vocabulary 문제
학습, 테스트 데이터의 domain이 다른 경우 성능이 떨어지는 문제
문장이 길어질 때 문맥을 이해하기 어려운 문제
language-pair 데이터가 많지 않은 문제

그리고 뿐만 아니라 NMT를 사용할 경우 아래와 같이 편향된 결과가 나올 수 있다.

Machine translation이 어떻게 발전해 왔는지 알아봤다. 최초의 방식부터 최근의 NMT 방식까지 다양한 모델들이 존재하는데, 그렇다면 machine translation 모델을 평가하는 것을 생각해보자. 사람이 직접하더라도 번역은 정답이 없는 문제이다. 하지만 우리는 모델을 평가해야 하는데 어떤 방식으로 평가할지를 정해야 한다. 따라서 평가 방식에 대해서 알아보자.

How to evaluate Machine translation

machine translation이 제대로 이뤄졌는지 확인하는 대표적인 지표는 ‘BLUE’ 점수이다. 이 방법 외에도 다양한 방법이 있지만 아직까지는 대부분 BLUE 점수를 통해서 모델을 평가한다. 그렇다면 BLUE는 어떤 방식으로 모델을 평가하는지 알아보도록 하자.

BLUE

BLUE(Bilingual Evaluation Understudy)란 기계에 의해 번역된 문장과 사람이 작성한 문장을 비교해서 유사도를 측정해서 성능을 측정하는 지표이다. 다음의 3가지 측면으로 평가를 한다.

n-gram precision: 1 ~ 4 gram으로 나눠 얼마나 맞는지 확인
문장 길이가에 대한 패널티를 곱한다.(짧은 문장에 패널티)
같은 단어에 대한 보정

위와 같은 계산 방식을 사용하며, 아직까지는 가장 많이 사용하는 지표이며, BLUE 점수가 절대적인것은 아니므로 다양한 지표로 평가를 해야한다.

Seqeunce to sequence

Sequence to sequence란 RNN을 사용해서 sequence를 다루는 모델이다. Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation 논문을 통해 처음 나왔으며 전체 내용에 대한 자세한 내용은 블로그 post를 참고하자.

전체적인 모델을 다음과 같다.

input sequence를 받아서 하나의 벡터로 encoding하는 앞부분과 encoding된 vector를 활용해서 output sequence를 만드는 decoder로 구성되어 있다.

Machine translation에 적용해보면 input은 번역할 문장이 되고 outout은 번역이 완료된 다른 언어의 문장이 될 것이다.

이 모델을 통해 처음으로 NMT가 시작되었지만 문제가 하나 있다. 모델을 보면 input을 단 하나의 벡터로 만드는데 이 과정에서 bottleneck 현상이 발생한다. 그리고 번역의 경우 alignment가 중요한데 위와 같은 구조로는 input의 alignment정보를 decoder로 전달하기 어렵다는 문제가 생긴다. 따라서 이러한 문제를 해결하기 위해서 사용된 기술이 Attention 기법이다.

Attention

attention은 Sequence to sequence with attention이라 불리는 논문인 Neural Machine Translation by Jointly Learning to Align and Translate에서 처음 제안된 기법이다. 이 논문에 대한 자세한 내용은 블로그 post를 참고하자.

Attention 기법은 input 문장의 alignment정보를 decoder에 전달하기 위해 사용된다. 기존의 모델을 생각하면 input에 대한 정보를 하나의 vector로 만들어 output sequence를 만들 때 사용했었다. attention이란 위의 encoding된 vector와 함께 alignment 정보를 같이 사용해서 계산한뒤 sequence의 각 값들을 계산한다. 아래의 그림을 참고하면 attention이 어떤 구조로 계산되는지 어느정도 이해할 수 있을 것이다.

output은 앞의 정보들을 계산해 가장 확률이 가장 높은 단어들이 나오는 구조인데, 이때 단순히 가장 높은 token을 선택하는 greedy한 방법을 사용하는 것이 아니라 Beam search라는 기법을 이용해서 output token을 선택한다. 마지막으로 beam search를 알아보자.

Beam Search

beam search란 정해둔 크기(beam size)의 개수만큼 높은 확률의 token을 계속해서 후보로 두고 전체 output sequence를 선택하는 방식이다. 아래의 그림을 보면 beam search를 직관적으로 이해할 수 있을 것이다.

CS20(TensorFlow) Lecture Note (11): RNNs in the TensorFlow

2018-09-06T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

11. RNNs in the TensorFlow

이번 lecture에서 배울 내용은 다음과 같다.

From feed-forward to recurrent
Tricks & treats
Presidential tweets

From feed-forward to Recurrent Neural Networks(RNNs)

지난 몇년간 feed-forward network 부터 convolutional neural network는 좋은 결과를 보여줬고 많은 문제에 적용시켜서 엄청난 성과를 보여줬다.

그럼에도 불구하고 아직도 이러한 feed-forward network와 convolutional neural network 모델로는 적용시키기 어려운 문제들이 아직 많이 있었다. 이러한 한계의 가장 큰 이유는 모델에 적용시킬 수 있는 data가 singular한 형태만 가능하기 때문이다. 따라서 언어나 음악과 같은 sequence데이터를 적용시키기에는 많은 어려움이 있었다. 따라서 위의 문제에 이어서 이런 sequencial한 데이터를 다루는 모델에 대해 연구가 많이 이뤄졌다.

이러한 연구의 결과로 나온것이 RNN이다. RNN은 sequential한 정보를 잡아내기 위해 만들어 졌고 가장 기본적인 형태의 RNN인 Simple Recurrent Network(SRN)은 Jeff Elman에 의해 만들어졌다.

RNN은 feed-forward의 unit과 똑같은 연산을 하는 unit이 적용되었다. 하지만 이러한 unit들이 계속해서 연결되어 있다는 점이다. Feed-forward의 경우 input에 의한 신호는 계속해서 한방향으로 이어지고, loop은 만들어 지지 않는다. 그에 반해 RNN은 loop이 생기고 neuron들이 각자 스스로 연결된다. 즉 이전의 neuron이 또 옆의 neuron에 영향을 준다.

가장 기본적인 형태의 RNN인 simple recurrent networks(SRN)은 Elman network와 Jordan network를 뜻한다.

Elman Network, Jordan Network

$\begin{align*} h_t &= \sigma_h(W_h x_t + U_h h_{t-1}+b_h)\\ y_t &=\sigma_y(W_y h_t+b_y) \end{align*}$

$x_t$ : input vector
$h_t$ : hidden layer vector
$y_t$ : output vector
$W,~U$ : and $b$ : parameter matrices and vector
$\sigma_h$ and $\sigma_y$ : Activation functions

대부분의 사람들은 RNN을 NLP의 한 분야라 생각한다. 그도 당연할 것이 언어가 매우 대표적인 sequential한 데이터이기 때문이다. 그러나 NLP분야 외에도 audio, image, video등 많은 분야에서도 RNN은 사용된다. 가령 MNIST의 경우에도 적용할 수 있다. 이 때는 각 image를 pixel들의 sequence로 적용시킨다.

Back-propagation through Time(BPTT)

Feed-forward와 Convolutional Network에서는 error를 back-propagation을 통해 loss 값이 모든 layer에 전달 되었다. 이런 방법을 통해 parameter들을 update시켰다.

RNN에서는 erros는 loss값이 모든 timestep에 전달된다. 앞선 내용과 두가지 큰 차이점이 있다.

feed-forward의 각 layer는 각자 자신의 parameter를 가지는 반면 RNN에서는 모든 timestep들이 parameter들을 공유한다. 따라서 모든 timestep의 gradient 값들을 모두 합쳐서 parameter를 update하는데 적용시켰다.
feed-forward의 경우 고정된 숫자의 layer를 가지는 반면 RNN은 임의의 timestep 수를 가진다.

아래의 차이점을 보자. 만약에 sequence가 매우 길어진다면, back-propagation은 모든 time-step에서 계산되는데 이 계산량이 매우 많아질 것이다. 또다른 본질적인 문제는 gradient 자체가 매우 커지거나 매우 작아져서 학습이 불가능한 경우가 생긴다.(vanishing/exploding gradients)

모든 timestep에서 모든 parameter를 update해서 계산량이 매우 많아지는 상황을 피하기 위해 보통 update시키는 timestep의 수를 제한시키는 방법을 사용한다.(truncated BPTT)

TensorFlow에서 RNN은 unrolled된 버전의 network를 사용한다. 즉 정확히 몇 개의 timestep을 사용할지를 정해줘야 한다는 뜻이다. RNN의 특성을 생각해보면 이러한 구현 방법은 큰 제약이 된다. input의 경우 길이가 일정할 수도 있지만 정해지지 않을 수도 있기 떄문이다. 예를 들면 여러 text를 다루는데 하나의 text는 20개의 단어로 구성되지만 또 어떤 text는 200개의 단어로 구성될 수 있기 때문이다. 이러한 문제를 해결하기 위한 하나의 방법은 data를 나눠서 각각 다른 bucket으로 넣는 것이다. 이 bucket에는 비슷한 크기의 sequence가 들어간다. 만약 becket보다 길이가 짧다면 padding을 이용하면 된다.

Gated Recurrent unit(LSTM and GRU)

실제로 RNN을 사용해보니 기대와는 달리 Long-term에 대한 정보를 잘 못잡아내는 것이 밝혀졌다. 이런 결함을 해결하기 위해 나온 것이 LSTM이다. 이러한 LSTM의 개발은 사실 오래전에 vanishing gradient 문제를 해결하기 위해 만들어 졌던 것이다.

LSTM의 unit은 gating mechanism이라 불리는 것을 위해 사용된다. 총 4개의 gate가 사용되고 일반적으로 $i,o,f,\tilde{c}$로 작성하고 각각 input, output, forget, candidate/new memory gate라 부른다.

$\begin{align*} &i^{(t)}=\sigma(W^{(i)}x^{(t)}+U^{(i)}h^{(t-1)})\\ &f^{(t)}=\sigma(W^{(f)}x^{(t)}+U^{(f)}h^{(t-1)})\\ &o^{(t)}=\sigma(W^{(o)}x^{(t)}+U^{(o)}h^{(t-1)})\\ &\tilde{c}^{(t)}=\tanh(W^{(c)}x^{(t)}+U^{(c)}h^{(t-1)})\\ &c^{(t)}=f^{(t)}\circ\tilde(c)^{(t-1)}+i^{(t)}\circ\tilde{c}^{(t)}\\ &h^{(t)}=o^{(o)}\circ\tanh(c^{(t)}) \end{algin*}$

직관적인 각 gate에 대한 이해는 다음과 같다.

input gate: 현재 input이 얼마나 사용할지 결정한다.
forget gate: 이전 state의 정보를 얼마나 사용할지 결정한다.
output gate: hidden state 값이 다음 timestep에 얼마나 전달할지 결정한다.
candidate gate: 일반적인 RNN와 유사한 부분이다. 이전 hidden state 값과 현재 input값을 기반으로 candidate를 계산한다.
final memory cell: candidate hidden state들을 합쳐서 내부의 memory 값을 만든다.

Long Term에 대한 정보를 잡아내기 위한 모델에 LSTM 뿐만 아니라 GRU도 많이 사용된다. 조금 다른 구조이지만 거의 유사한 방식으로 동작한다.

Application

RNN모델을 활용한 application은 다음과 같다.

Language modeling
Machine Translation
Text Summarization
Image Captioning

RNN in TensorFlow

RNN은 기본적으로 하나하나의 cell들이 결합된 구조이다. TensorFlow에서는 여러가지 RNN 모델을 만들기 위해 다음과 같은 cell들을 지원한다.

BasicRNNCell: 가장 기본적인 RNN cell
RNNCell: RNN Cell을 위한 Abstract Object
BasicLSTMCell: 기본적인 LSTM recurrent network cell
LSTMCell: LSTM recurrent network cell
GRUCell: GRU cell

위의 cell들은 다음과 같이 구현한다.

cell = tf.nn.rnn_cell.GRUCell(hidden_size)

그리고 RNN의 모델을 생각해보자. cell들이 stacked된 구조이다. 따라서 여러개의 cell들을 쌓아야하는데 다음과 같이 구현하면 된다.

layers = [tf.nn.rnn_cell.GRUCell(size) for size in hidden_sizes]
cells = tf.nn.rnn_cell.MultiRNNCell(layers)

그리고 동적으로 graph를 만들기 위해 tf.nn.dynamic_rnn, tf.nn.bidirectional_dynamic_rnn를 사용한다. 설명은 다음과 같다.

tf.nn.dynamic_rnn: tf.While loop을 사용해서 동적으로 graph를 만든다. graph의 생성이 빠르고 batch를 가변 크기로 사용할 수 있다.(batch의 가변길이가 sequence의 가변길이를 뜻하진 않음)
tf.nn.bidirectional_dynamic_rnn: 위와 같은 방식이지만 양방향의 RNN을 만들 수 있다.

dynamic_rnn을 사용해서 다음과 같이 RNN들을 stack 할 수 있다.

layers = [tf.nn.rnn_cell.GRUCell(size) for size in hidden_sizes]
cells = tf.nn.rnn_cell.MultiRNNCell(layers)
output, out_state = tf.nn.dynamic_rnn(cell, seq, length, initial_state)

하지만 앞서 소개한 RNN의 제약을 생각해보자. sequence는 어느정도 비슷한 크기를 가져야 했었다. 따라서 일정 크기(max_length)를 정하고 그 크기보다 큰 경우 자르고 크기보다 작은 경우에는 zero-padding을 사용한다.

하지만 padding을 사용하는 것에도 새로운 문제가 생긴다. input 뿐만 아니라 label에도 padding을 해야하는데 이렇게 label에 padding을 하게되면 loss에 영향을 줘서 학습에 문제가 생길 수 있다. 이를 해결하기 위한 두 가지 접근법이 있다.

Approach 1
- mask를 사용한다. 실제 label에는 True값을 주고 padding된 label에는 False를 준다.
- model을 real/padded token 모두를 가지고 돌린다.
- real 값들만을 가지고 loss를 계산한다.

이 방법을 사용하기 위한 구현은 다음과 같다.

full_loss = tf.nn.softmax_cross_entropy_with_logits(preds, labels)
loss = tf.reduce_mean(tf.boolean_mask(full_loss, mask))

Approach 2
- model에게 실제 sequence 길이를 알려줘서 예측도 실제 길이만큼만 하도록 해서 label과 비교한다.

이 방법을 사용한 구현은 다음과 같다. (line 3)

cell = tf.nn.rnn_cell.GRUCell(hidden_size)
rnn_cells = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers)
tf.reduce_sum(tf.reduce_max(tf.sign(seq), 2), 1)
output, out_state = tf.nn.dynamic_rnn(cell, seq, length, initial_state)

Tips and Tricks for implementation

Vanishing Gradient

RNN의 중요한 문제점 중 하나인 Vanishing gradient를 막기위해서는 다음과 같은 방법을 사용할 수 있다.

다른 종류의 Activation 함수 사용하기(ReLU계열)
- tf.nn.relu
- tf.nn.relu6
- tf.nn.crelu
- tf.nn.elu
다른 종류의 Activation 함수 사용하기(기타)
- tf.nn.softplus
- tf.nn.softsign
- tf.nn.bias_add
- tf.sigmoid
- tf.tanh

Exploding Gradient

그리고 또 하나의 문제점인 Exploding gradient를 방지하기 위해서 gradient 값을 일정 크기 이상 못올라가도록 제한시킨다.

# 모든 학습가능한 변수들에 대한 cost의 gradient를 구한다.
gradients = tf.gradients(cost, tf.trainable_variables())

# gradient를 일정 크기 이상 못올라가도록 할 clip을 정의한다.
clipped_gradients, _ = tf.clip_by_global_norm(gradients, max_grad_norm)


optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.apply_gradients(zip(gradients, trainables))

Anneal learning rate

학습률(learning rate)를 학습 과정에서 점차 감소키는 방법은 다음과 같다.

learning_rate = tf.train.exponential_decay(init_lr,
										   global_step,
										   decay_steps,
										   decay_rate,
										   staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate)

Overfitting

Dropout을 사용해서 overfitting을 방지하는데 dropout을 사용하는 방법은 tf.nn.dropout을 사용하는 방법과, DropoutWrapper를 사용하는 두 가지 방법이 있다.

tf.nn.dropout

hidden_layer = tf.nn.dropout(hidden_layer, keep_prob)

DropoutWrapper

cell = tf.nn.rnn_cell.GRUCell(hidden_size)
cell = tf.nn.rnn_cell.DropoutWrapper(cell,     
                                    output_keep_prob=keep_prob)

Language Modeling in TensorFLow

이번에는 TensorFlow를 통해 Language modeling을 구현해보도록 한다. 우선 어떤 language modeling을 할지 부터 정해야 하는데, 보통 흔히 사용되는 Neural Language Modeling은 다음과 같다.

Word-level: n-gram
- 매우 전통적인 모델이다.
- 특정 단어 이전의 n개의 단어를 통해 특정 단어를 예측하는 모델.
- 단어를 미리 저장하는 vocabulary가 필요한데 이 크기가 매우 크다.
- Out-of-vocabulary에 대한 대처가 필요하다.
- 많은 메모리를 요구한다.
Character-level
- input과 output모두 문자 하나하나로 구성된다.
- vocabulary 크기가 매우 작다(영어의 경우 소문자 26개)
- 단어 embedding 과정이 필요없다.
- 학습이 빠르다.
- 유연하지 않은 단점이 있다.
Subword-level:
- input과 output이 subword이다.
- W개의 가장 자주나오는 단어와, S개의 자주나오는 음절을 정한 후 기존 text를 변형 시킨다. (e.g new company dreamworks interactive -> new company dre+ am+ wo+ rks: in+ te+ ra+ cti+ ve:)
- word-level과 char-level보다 좋은 성능을 보인다.

이번 구현에서는 Character-level의 모델을 만들어 보도록 한다. 데이터는 ‘Donald Trump’s tweets’데이터로 2018년 2월 15일까지의 donald trump의 트윗으로 구성되어 있다. 총 19,469개의 트윗이 있으며 각각 최대 140자이다. 그리고 트윗의 모든 링크들 즉, URL은 __HTTP__로 작성되어 있다. 데이터를 학습시킨 후 나온 결과는 다음과 같다.

이제 구현을 해보자. 먼저 우리가 사용할 라이브러리들을 import먼저 한다.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import random
import sys
sys.path.append('..')
import time

import tensorflow as tf

import utils

우선은 char를 각각의 input으로 넣는다고 했었다. 그렇다고 input으로 바로 ‘c’를 넣는 것이 아니라 전체 character들을 vocabulary에 넣고 각 character를 index화 시켜서 input으로 넣는다. 즉 각 input의 character에 해당하는것을 vocabulary에서 찾고 index를 반환하는 encode함수와 출력시 다시 숫자를 character로 바꿔주는 decode함수부터 구현한다.

# encode 후 index를 0이 아닌 1부터 갖도록 만든다.
def vocab_encode(text, vocab):
    return [vocab.index(x) + 1 for x in text if x in vocab]

def vocab_decode(array, vocab):
    return ''.join([vocab[x - 1] for x in array])

이제 데이터를 불러오는 함수를 만들어야 한다. 데이터는 txt 파일로 되어있다. 각 데이터를 한 줄씩 읽어와서 위에 정의한 encode함수를 사용해서 vector화 시켜준다.

def read_data(filename, vocab, window, overlap):
    lines = [line.strip() for line in open(filename, 'r').readlines()]
    while True:
        random.shuffle(lines)

        for text in lines:
            text = vocab_encode(text, vocab)
            for start in range(0, len(text) - window, overlap):
                chunk = text[start: start + window]
                chunk += [0] * (window - len(chunk))
                yield chunk

그리고 불러온 데이터를 배치화 시켜주는 함수를 만든다.

def read_batch(stream, batch_size):
    batch = []
    for element in stream:
        batch.append(element)
        if len(batch) == batch_size:
            yield batch
            batch = []
    yield batch

이제 전체 모델을 Class 형태로 만들어 준다.

class CharRNN(object):
    def __init__(self, model):
        self.model = model
        self.path = 'data/' + model + '.txt'
        self.vocab = ("$%'()+,-./0123456789:;=?ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                    " '\"_abcdefghijklmnopqrstuvwxyz{|}@#➡📈")
        self.seq = tf.placeholder(tf.int32, [None, None])
        self.temp = tf.constant(1.5)
        self.hidden_sizes = [128, 256]
        self.batch_size = 64
        self.lr = 0.0003
        self.skip_step = 1
        self.num_steps = 50 # for RNN unrolled
        self.len_generated = 200
        self.gstep = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')

    def create_rnn(self, seq):
        layers = [tf.nn.rnn_cell.GRUCell(size) for size in self.hidden_sizes]
        cells = tf.nn.rnn_cell.MultiRNNCell(layers)
        batch = tf.shape(seq)[0]
        zero_states = cells.zero_state(batch, dtype=tf.float32)
        self.in_state = tuple([tf.placeholder_with_default(state, [None, state.shape[1]])
                                for state in zero_states])
        # this line to calculate the real length of seq
        # all seq are padded to be of the same length, which is num_steps
        length = tf.reduce_sum(tf.reduce_max(tf.sign(seq), 2), 1)
        self.output, self.out_state = tf.nn.dynamic_rnn(cells, seq, length, self.in_state)

    def create_model(self):
        seq = tf.one_hot(self.seq, len(self.vocab))
        self.create_rnn(seq)
        self.logits = tf.layers.dense(self.output, len(self.vocab), None)
        loss = tf.nn.softmax_cross_entropy_with_logits(logits=self.logits[:, :-1],
                                                        labels=seq[:, 1:])
        self.loss = tf.reduce_sum(loss)
        # sample the next character from Maxwell-Boltzmann Distribution
        # with temperature temp. It works equally well without tf.exp
        self.sample = tf.multinomial(tf.exp(self.logits[:, -1] / self.temp), 1)[:, 0]
        self.opt = tf.train.AdamOptimizer(self.lr).minimize(self.loss, global_step=self.gstep)

    def train(self):
        saver = tf.train.Saver()
        start = time.time()
        min_loss = None
        with tf.Session() as sess:
            writer = tf.summary.FileWriter('graphs/gist', sess.graph)
            sess.run(tf.global_variables_initializer())

            ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/' + self.model + '/checkpoint'))
            if ckpt and ckpt.model_checkpoint_path:
                saver.restore(sess, ckpt.model_checkpoint_path)

            iteration = self.gstep.eval()
            stream = read_data(self.path, self.vocab, self.num_steps, overlap=self.num_steps//2)
            data = read_batch(stream, self.batch_size)
            while True:
                batch = next(data)

            # for batch in read_batch(read_data(DATA_PATH, vocab)):
                batch_loss, _ = sess.run([self.loss, self.opt], {self.seq: batch})
                if (iteration + 1) % self.skip_step == 0:
                    print('Iter {}. \n    Loss {}. Time {}'.format(iteration, batch_loss, time.time() - start))
                    self.online_infer(sess)
                    start = time.time()
                    checkpoint_name = 'checkpoints/' + self.model + '/char-rnn'
                    if min_loss is None:
                        saver.save(sess, checkpoint_name, iteration)
                    elif batch_loss < min_loss:
                        saver.save(sess, checkpoint_name, iteration)
                        min_loss = batch_loss
                iteration += 1

    def online_infer(self, sess):
        """ Generate sequence one character at a time, based on the previous character
        """
        for seed in ['Hillary', 'I', 'R', 'T', '@', 'N', 'M', '.', 'G', 'A', 'W']:
            sentence = seed
            state = None
            for _ in range(self.len_generated):
                batch = [vocab_encode(sentence[-1], self.vocab)]
                feed = {self.seq: batch}
                if state is not None: # for the first decoder step, the state is None
                    for i in range(len(state)):
                        feed.update({self.in_state[i]: state[i]})
                index, state = sess.run([self.sample, self.out_state], feed)
                sentence += vocab_decode(index, self.vocab)
            print('\t' + sentence)

마지막으로 구현한 모델들을 실행시키는 main함수를 넣으면 끝난다.

def main():
    model = 'trump_tweets'
    utils.safe_mkdir('checkpoints')
    utils.safe_mkdir('checkpoints/' + model)

    lm = CharRNN(model)
    lm.create_model()
    lm.train()

if __name__ == '__main__':
    main()

RNN을 통해 character단위 뿐만 아니라 word level등 다양한 모델을 만들 수 있으므로 이번 기회에 자세히 알아보도록 하자.

CS20(TensorFlow) Lecture Note (8): CNN(Style transfer), TFRecord

2018-08-16T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

8. CNN(Style transfer), TFRecord

이번 lecture에서는 TFRecord와 Style transfer에 대해서 알아보도록 한다. TFRecord란 텐서플로우 데이터 포맷이다. tensorflow에서 추천하는 포맷인 만큼 이번 장에서 알아보자.

TFRecord

TFRecord는 TensorFlow 데이터 포맷으로, 바이너리 형식으로 저장된다. 따라서 dick cache를 효율적으로 사용하고, 사용 시 속도가 빠르다. 그리고 바이너리 형식이라 다른 형식의 데이터들도 같이 다룰 수 있다.(image 와 label을 같이 넣을 수 있다)

image와 label을 TFRecord 파일로 저장하는 방법에 대해서 알아보자.

먼저 TFRecord 파일을 작성할 writer를 만든다.

writer = tf.python_io.TFRecrodWriter(out_file)

그리고 image의 shape과 value(binary)를 가져온다.

shape, binary_image = get_image_binary(image_file)

다음으로 tf.train.Features 객체를 만든다.

features = tf.train.Features(feature = {'label': _int64_feature(label),
                                        'shape': _bytes_feature(shape),
                                        'image': _bytes_feature(binary_image)})

위에서 정의한 feature들을 포함하는 sample을 만든다.

sample = tf.train.Example(features = features)

마지막으로 sample을 TFRecord파일로 작성한후 writer를 close한다.

writer.write(sample.SerializeToString())
writer.close()

TFRecord파일로 저장하는 방법이 끝났다. 위의 저장하는 과정을 보면 각각 int와 byte값으로 형식이 다르더라도 같이 저장할 수 있다는 장점이 있다.

위에서 사용한 각 다른 데이터 형식을 하나의 byte string으로 만드는 함수인 _int64_feature와 _bytes_feature는 다음과 같이 정의된다.

def _int64_feature(value):
    return tf.train.Feature(int64_list = tf.train.Int64List(value=[value]))
def _bytes_feature(value):
    return tf.train.Feature(bytes_list = tf.train.Bytes64List(value=[value]))

이제 저장한 TFRecord 파일을 사용하는 방법에 대해서 알아보자. tf.data를 이용해서 불러올 수 있다.

dataset = tf.data.TFRecordDataset(tfrecord_files)

위와 같이 불러올 수 있다. 하지만 저장할 때를 생각해보자. 각각 다른 데이터 형식을 하나의 데이터로 저장했었다. 따라서 불러온 후 다시 다른 데이터 형식은 나눠줘야 한다. 따라서 파싱하는 함수인 _parse_function_을 정의한후 이용하면 된다.

def _parse_function(tfrecord_serialized):
    features={'label': tf.FixedLenFeature([], tf.int64),
              'shape': tf.FixedLenFeature([], tf.string),
              'image': tf.FixedLenFeature([], tf.string)}

그리고 정의한 함수를 데이터의 mapping 함수로 적용하면 된다.

dataset = dataset.map(_parse_function)

TFRecord를 이용해서 데이터를 저장하고 불러오는 방법에 대해서 알아봤다. 전체 코드는 github를 참고하자.

Style transfer

Style transfer란 두개의 이미지를 사용해서 하나의 이미지에 다른 하나의 이미지의 style을 적용시키는 모델이다. 아래 그림은 Deadpool 그림이다.

그리고 아래는 Picasso의 Guernica라는 그림이다.

이 두 이미지를 가지고 style transfer 모델에 적용시키면, Picasso의 Guernica그림의 style을 Deadpool 그림에 적용시킬 수 있다. 즉 아래의 그림처럼 된다.

이 모델에서는 중요한 두가지 loss가 정의된다. 여기서 내용 이미지는 위의 예시로 보면 Deadpool 이미지가 되고 스타일 이미지는 피카소의 이미지가 된다.

Content loss

내용 이미지의 내용과 생성된 이미지의 내용간의 content loss를 측정

$\mathcal{L}_{content}(\vec{p}, \vec{x}, l) = \frac{1}{2}\sum_{i,j}(F^l_{ij}-P^l_{ij})^2$

Style loss

스타일 이미지의 스타일과 생성된 이미지의 스타일간의 style loss를 측정

$\begin{matrix} E_l=\frac{1}{4N^2_lM^2_l}\sum_{ij}(G^l_{ij}-A^l_{ij})^2\\ \mathcal{L}(\vec{a}, \vec{x})=\sum^L_{l=0}w_lE_l \end{matrix}$

그리고 이 모델의 Optimizer는 두개의 loss를 같이 최소화 하도록 한다.

$\mathcal{L}_{total}(\vec{p},\vec{a},\vec{x})=\alpha\mathcal{L}_{content}(\vec{p},\vec{x})+\beta\mathcal{L}_{style}(\vec{a},\vec{x})$

그리고 구현 과정에 대해서 설명하면 다음과 같다.

가중치 대신 input값을 학습한다.
같은 변수를 공유해서 사용한다.
Pre-trained 된 가중치를 사용했다.(VGG-19)

CS20(TensorFlow) Lecture Note (6), (7): Intro to ConvNet & ConvNet in TensorFlow

2018-08-16T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

6. Intro to ConvNet

5장에서는 Convolution에 대한 소개를 하고 있고, 6장에서는 Convolutional Neural Network를 TensorFlow에서 구현하는 방법에 대해서 설명하고 있다. 5장의 내용인 CNN에 대한 소개는 블로그 포스팅으로 대체 한다. 아래의 글들을 참고하자.

7. ConvNet in TensorFlow

Convolutional Neural Network에 대해서는 위 글들을 통해 확인 했다면 이제 CNN을 TensorFLow에서 구현하는 방법에 대해서 알아보자. 우선은 Convolution을 구현하기 위한 핵심 모듈인 tf.nn.conv2d에 대해서 알아보자. 함수는 아래와 같이 구성된다.

tf.nn.conv2d(
    input,
    filter,
    strides,
    padding,
    use_cudnn_on_gpu=True,
    data_format='NHWC',
    dilations=[1, 1, 1, 1],
    name=None)

input과 filter, 그리고 Stride의 형태는 다음과 같다.

Input: Batch Size (N) x Height (H) x Width (W) x Channels (C)
Filter: Height x Width x Input Channels(channel) x Output Channel(# of filters)
Stride: 1 x stride x stride x 1

conv2d는 우리가 흔히 사용하는 일반적인 Convolution이라고 생각하면 된다. 그렇다면 또 다른 convolution 모듈인 tf.nn.conv1d, tf.nn.conv3d와는 어떤 차이가 있을까?

큰 차이는 Output의 형태, convolution이 수행되는 방향(direction) 이 두 가지로 분류할 수 있다.

Output의 shape

Conv	특징
`conv1d`	output이 1D array(vector)가 된다.
`conv2d`	output이 2D array(matrix)가 된다.
`conv3d`	output이 3D array(tensor)가 된다.

Convolution이 수행되는 방향

Conv	특징
`conv1d`	한 방향으로만 수행된다. (1-direction)
`conv2d`	두 방향으로 수행된다. (2-direction)
`conv3d`	세 방향으로 수행된다. (3-direction)

위의 두 가지 차이점 외에 또 다른 차이점은 filter의 크기와 관련되어있다.

Filter의 크기

Conv	특징
`conv1d`	input과 filter의 Height(dimension), channel값이 같다.
`conv2d`	input과 filter의 channel만 같다.(Height은 filter가 더 작다)
`conv3d`	filter의 height과 channel이 모두 input보다 작다.

사실상 위의 세가지 차이점 모두 일맥 상통하는 얘기이다. 마지막 차이점이 있기 떄문에 direction이 차이가 생기고 이 차이 때문에 output값의 차이가 생기는 것이다.

아래의 그림을 보면 좀더 명확히 이해가 될 것이다.

conv1d

conv2d

conv3d

(출처: https://stackoverflow.com/questions/42883547/what-do-you-mean-by-1d-2d-and-3d-convolutions-in-cnn)

이제 MNIST 데이터를 Classification하는 Convolutional Neural Network를 TensorFlow로 구현하는 방법에 대해서 알아보자.

ConvNet on MNIST

이전 3강에서 MNIST 손글씨 이미지를 Logistic Regression을 통해 분류하는 모델을 이미 만들었다. 이번에는 CNN 모델을 통해 MNIST 분류기를 만들어 보도록 한다.

먼저 우리가 만들 모델에 대해서 간략히 소개하면, 두개의 conv layer를 사용하고 각각 ReLU함수와 max-pooling layer를 적용하고, 두개의 fully connected layer를 사용한다. stride = 1 으로 적용한다. 만들 모델을 도식화하면 다음과 같다.

모델을 보면 (Conv + ReLU), (Max-Pooling), (fc layer)를 각각 두번씩 적용하기 때문에 재사용가능 하도록 함수로 정의한 후 모델을 만든다.

Convolutional layer

앞서 설명한 tf.nn.cocnv2d를 사용해서 convolutional layer를 구현할 것이다. 여기에 우리는 활성화 함수 ReLU를 추가하면 된다. 아래와 같이 함수를 정의하자.

def conv_relu(inputs, filters, k_size, stride, padding, scope_name):
    with tf.variable_scope(scope_name, reuse=tf.AUTO_REUSE) as scope:
        in_channels = inputs.shape[-1]
        kernel = tf.get_variable('kernel', [k_size, k_size, in_channels, filters],
                                initializer=tf.truncated_normal_initializer())
        biases = tf.get_variable('biases', [filters],
                            initializer=tf.random_normal_initializer())
        conv = tf.nn.conv2d(inputs, kernel, strides=[1, stride, stride, 1], padding=padding)
    return tf.nn.relu(conv + biases, name=scope.name)

중간의 in_channels 값은 Image의 channel 값이 된다. RGB이미지는 채널이 3이 될 것이고 MNIST는 흑백 이미지 이므로 1이 된다.

다음 함수를 정의하기 전에 output의 size를 구하는 공식을 확인하고 넘어가자.

Input 크기 ($W$)
Filter 크기 ($F$)
Stride 값 ($S$)
padding 값 ($P$)

위와 같이 입력값을 가질때 output의 size는 다음과 같다.

$\frac{W-F+2P}{S}+1$

우리가 만드는 MNIST 모델에서 적용해보면, input은 28x28 size이고, filter는 5x5크기를 사용한다. 그리고 stride는 1, padding은 2를 사용한다. 따라서 output의 크기는 다음과 같다.

$\frac{28-5+2\times2}{1}+1 = 28$

Pooling

Pooling은 feature map의 차원 수를 감소시켜서 특징을 추출하고, 수행 시간을 감소시키는 역할을 한다. 보통 max-pooling 혹은 average-pooling을 사용한다. 이 모델에서는 max-pooling을 사용하므로 아래와 같이 max-pooling 함수를 정의하자.

def maxpool(inputs, ksize, stride, padding='VALID', scope_name='pool'):
    with tf.variable_scope(scope_name, reuse=tf.AUTO_REUSE) as scope:
        pool = tf.nn.max_pool(inputs,
                            ksize=[1, ksize, ksize, 1],
                            strides=[1, stride, stride, 1],
                            padding=padding)
    return pool

pooling을 적용시켰을 떄의 output 크기의 공식은 다음과 같다.

input 크기 ($W$)
pooling 크기 ($K$)
pooling 시 stride 값 ($S$)
padding 값 ($P$)

$\frac{W-K+2P}{S}+1$

우리의 모델에서는 input은 28x28이고, pooling 크기는 2x2이고, stride는 2이고, padding은 하지 않으므로 다음과 같이 output 크기를 가질 것이다.

$\frac{28-2+2\times0}{2}+1=14$

Fully Connected

fc layer를 정의해야 한다. 아래와 같이 정의하자.

def fully_connected(inputs, out_dim, scope_name='fc'):
    with tf.variable_scope(scope_name, reuse=tf.AUTO_REUSE) as scope:
        in_dim = inputs.shape[-1]
        w = tf.get_variable('weights', [in_dim, out_dim],
                            initializer=tf.truncated_normal_initializer())
        b = tf.get_variable('biases', [out_dim],
                            initializer=tf.constant_initializer(0.0))
        out = tf.matmul(inputs, w) + b
    return out

Putting it together

이제 만든 함수들을 하나로 모아서 전체 모델을 만들자. 순서대로 우리가 만든 함수를 사용하면 된다. 하나 유의할 점은 마지막 pooling 후 fc-layer로 갈 때 3차원 배열이였던 것을 1차원으로 reshape해줘야 하는데, 이 때 1차원 vector의 크기는 원래 배열의 각 차원의 길이를 곱해줘서 구하면 된다. 그리고 마지막으로 fc-layer에 dropout을 한번 적용한다.

def inference(self):
        conv1 = conv_relu(inputs=self.img,
                        filters=32,
                        k_size=5,
                        stride=1,
                        padding='SAME',
                        scope_name='conv1')
        pool1 = maxpool(conv1, 2, 2, 'VALID', 'pool1')
        conv2 = conv_relu(inputs=pool1,
                        filters=64,
                        k_size=5,
                        stride=1,
                        padding='SAME',
                        scope_name='conv2')
        pool2 = maxpool(conv2, 2, 2, 'VALID', 'pool2')
        feature_dim = pool2.shape[1] * pool2.shape[2] * pool2.shape[3]
        pool2 = tf.reshape(pool2, [-1, feature_dim])
        fc = tf.nn.relu(fully_connected(pool2, 1024, 'fc'))
        dropout = tf.layers.dropout(fc, self.keep_prob, training=self.training, name='dropout')

        self.logits = fully_connected(dropout, self.n_classes, 'logits')

그리고 만든 모델을 통해 예측값을 뽑는 함수를 정의한다.

def eval(self):
        '''
        Count the number of right predictions in a batch
        '''
        with tf.name_scope('predict'):
            preds = tf.nn.softmax(self.logits)
            correct_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(self.label, 1))
            self.accuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))

전체 코드는 github를 참고하자.

이제 실행한 뒤 TensorBoard로 loss값과 accuracy 값을 확인 해보면 다음과 같이 나올 것이다.

그리고 총 25 epoch을 학습 시키면 Accuracy가 98%가 나온다. 간단한 모델임에도 불구하고 매우 높은 수치의 정확도를 보여준다!

CS20(TensorFlow) Lecture Note (5): word2vec + manage experiments

2018-08-16T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

5. word2vec + manage experiments

이때까지는 간단한 모델을 만드는 방법에 대해서 알아보았다. 이번 강의에서는 이전 보다는 좀 더 복잡한 모델인인 word2vec을 예제로 모델을 만들어 보도록 한다. 이번 모델을 만들면서 variable sharing, model sharing 그리고 manage our experiments에 대해서 알아보도록 할 것이다.

Word2vec

단어 임베딩을 하는 방법 중에서 가장 널리 알려지고 많이 사용되는 기술은 word2vec일 것이다. 내용에 대해서는 아마 대부분이 알고 있을 것이라 생각하고 자세한 내용은 설명하지 않는다. 만약 잘 모른다면 다음의 글들을 참고하자 : paper1, paper2, blog1, blog2

word2vec의 두 가지 모델(skip-gram, CBOW)중에서 이번 강의에서는 skip-gram 모델을 구현해보도록 한다.

Implementing word2vec

여기서는 Session을 사용할 것이다. eager를 사용하는 모델은 examples/04_word2vec_eager.py 파일을 참고하자.

우선은 우리가 사용할 라이브러리들을 임포트한다.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

import numpy as np
from tensorflow.contrib.tensorboard.plugins import projector
import tensorflow as tf

import utils
import word2vec_utils

word2vec_utils은 중간에 사용되는 몇 가지 기능들을 미리 만들어 놓은 파이썬 파일이다. 그리고 다음으로는 모델의 하이퍼 파라미터를 정의하자.

VOCAB_SIZE = 50000
BATCH_SIZE = 128
EMBED_SIZE = 128            # dimension of the word embedding vectors
SKIP_WINDOW = 1             # the context window
NUM_SAMPLED = 64            # number of negative examples to sample
LEARNING_RATE = 1.0
NUM_TRAIN_STEPS = 100000
VISUAL_FLD = 'visualization'
SKIP_STEP = 5000

DOWNLOAD_URL = 'http://mattmahoney.net/dc/text8.zip'
EXPECTED_BYTES = 31344016
NUM_VISUALIZE = 3000        # number of tokens to visualize

우선은 이제 데이터를 다운받고 tf.data를 정의해야 한다. 데이터의 구조에 대해서 먼저 설명하면, skip-gram에서는 input값은 중간의 단어가 되고 output은 단어 주변의 context 단어가 된다. 하지만 여기서 구현할 때는 단어 자체를 input으로 넣지 않고 흔한 단어들에 대해서 dictionary를 만들고 input은 중간 단어에 대한 vocabulary에서의 index값을 줄 것이다. 예를 들어 만약 vocabulary에서 1000번째 단어인 경우에는 input = 3 이 된다.

데이터를 다운로드하고, 각 데이터를 정해진 hyperparameter에 맞게 input 값인 인덱스들을 배치사이즈로 만들어 주는 함수를 미리 정의했다. 이 함수는 word2vec_utils.py에 정의되어 있으며 이 과정의 세부적인 내용은 해당 파이썬 파일을 참고하자.

여기서는 해당 함수를 사용해서 데이터를 tf.data로 불러온 후 iterator를 정의하자.

dataset = tf.data.Dataset.from_generator(gen,
                              (tf.int32, tf.int32),
                              (tf.TensorShape([BATCH_SIZE]), tf.TensorShape([BATCH_SIZE, 1])))

iterator = dataset.make_initializable_iterator()
center_words, target_words = iterator.get_next()

skip-gram모델에서의 파라미터는 매트릭스 형태인데, 이 매트릭스의 row vector가 단어 임베딩 벡터가 된다. 따라서 매트릭스의 크기는 [VOCAB_SIZE, EMBED_SIZE]가 된다. 해당 파라미터 매트릭스는 보통 random distribution을 따르도록 초기화하는데, 여기서는 uniform distribution을 따르도록 초기화 하자.

embed_matrix = tf.get_variable('embed_matrix',
                                shape=[VOCAB_SIZE, EMBED_SIZE],
                                initializer=tf.random_uniform_initializer())

skip-gram모델에서 단어는 원래 one-hot 인코딩 되어 있고 파라미터와 곱해질 떄 아래 그림 처럼 결국 특정 행만 계산된다. 결국 나머지는 모두 0이 됨에도 불구하고 모두 계산된다. TensorFlow에서는 이와 같은 문제를 해결하기 위한 함수인 tf.nn.embedding_lookup함수를 제공한다. 따라서 이 함수를 통해 batch의 단어들에 해당하는 row의 vector 값들만 사용 할 수 있다.

tf.nn.embedding_lookup함수의 구조는 아래와 같다.

tf.nn.embedding_lookup(
    params,
    ids,
    partition_strategy='mod',
    name=None,
    validate_indices=True,
    max_norm=None
)

따라서 위의 함수를 다음과 같이 사용한다.

embed = tf.nn.embedding_lookup(embed_matrix, center_words, name='embedding')

이제 loss함수를 정의해야 한다. loss함수로 NCE함수를 사용할 것이다. 이미 tf에서 이 함수를 제공하고 있으므로 사용하도록 하자. NCE함수는 아래와 같이 구성되어 있다.

tf.nn.nce_loss(
    weights,
    biases,
    labels,
    inputs,
    num_sampled,
    num_classes,
    num_true=1,
    sampled_values=None,
    remove_accidental_hits=False,
    partition_strategy='mod',
    name='nce_loss'
)

(위 함수의 인자 중에서 3번 째가 실제로는 input이고, 4번째가 label이다)

NCE loss를 사용하기 위해 nce_weight과 nce_bias를 따로 만들어 준 후 loss 함수를 정의하자.

nce_weight = tf.get_variable('nce_weight', shape=[VOCAB_SIZE, EMBED_SIZE],
                initializer=tf.truncated_normal_initializer(stddev=1.0 / (EMBED_SIZE ** 0.5)))
nce_bias = tf.get_variable('nce_bias', initializer=tf.zeros([VOCAB_SIZE]))

loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weight,
                                        biases=nce_bias,
                                        labels=target_words,
                                        inputs=embed,
                                        num_sampled=NUM_SAMPLED,
                                        num_classes=VOCAB_SIZE), name='loss')

이제 optimizer만 정의하면된다. gradient descent optimizer를 사용한다.

optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(loss)

이제 정의한 graph를 실행하면 된다. Session을 통해 실행하자.

sess.run(iterator.initializer)
    sess.run(tf.global_variables_initializer())

    total_loss = 0.0 # we use this to calculate late average loss in the last SKIP_STEP steps
    writer = tf.summary.FileWriter('graphs/word2vec_simple', sess.graph)

    for index in range(NUM_TRAIN_STEPS):
        try:
            loss_batch, _ = sess.run([loss, optimizer])
            total_loss += loss_batch
            if (index + 1) % SKIP_STEP == 0:
                print('Average loss at step {}: {:5.1f}'.format(index, total_loss / SKIP_STEP))
                total_loss = 0.0
        except tf.errors.OutOfRangeError:
            sess.run(iterator.initializer)
    writer.close()

여기까지 하면 tensorflow로 만든 word2vec 모델이 다 끝났다. 매우 짧은 코드만으로도 복잡한 모델인 word2vec의 skip-gram을 구현했다. 코드를 다시 보면 매우 간단하지만 다시 사용하기는 어려울 것이다. 그렇다면 어떻게 해야 다시 사용하기 쉽도록 코드를 구성할 것인가?

정답은 Class 구조로 만드는 것이다. 위의 코드들을 Class구조로 만들면 다음과 같이 구성된다.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

import numpy as np
from tensorflow.contrib.tensorboard.plugins import projector
import tensorflow as tf

import utils
import word2vec_utils

VOCAB_SIZE = 50000
BATCH_SIZE = 128
EMBED_SIZE = 128            # dimension of the word embedding vectors
SKIP_WINDOW = 1             # the context window
NUM_SAMPLED = 64            # number of negative examples to sample
LEARNING_RATE = 1.0
NUM_TRAIN_STEPS = 100000
VISUAL_FLD = 'visualization'
SKIP_STEP = 5000

DOWNLOAD_URL = 'http://mattmahoney.net/dc/text8.zip'
EXPECTED_BYTES = 31344016
NUM_VISUALIZE = 3000       


def word2vec(dataset):

    with tf.name_scope('data'):
        iterator = dataset.make_initializable_iterator()
        center_words, target_words = iterator.get_next()

    with tf.name_scope('embed'):
        embed_matrix = tf.get_variable('embed_matrix',
                                        shape=[VOCAB_SIZE, EMBED_SIZE],
                                        initializer=tf.random_uniform_initializer())
        embed = tf.nn.embedding_lookup(embed_matrix, center_words, name='embedding')

    with tf.name_scope('loss'):
        nce_weight = tf.get_variable('nce_weight', shape=[VOCAB_SIZE, EMBED_SIZE],
                        initializer=tf.truncated_normal_initializer(stddev=1.0 / (EMBED_SIZE ** 0.5)))
        nce_bias = tf.get_variable('nce_bias', initializer=tf.zeros([VOCAB_SIZE]))

        loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weight,
                                            biases=nce_bias,
                                            labels=target_words,
                                            inputs=embed,
                                            num_sampled=NUM_SAMPLED,
                                            num_classes=VOCAB_SIZE), name='loss')


    with tf.name_scope('optimizer'):
        optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(loss)

    utils.safe_mkdir('checkpoints')

    with tf.Session() as sess:
        sess.run(iterator.initializer)
        sess.run(tf.global_variables_initializer())

        total_loss = 0.0
        writer = tf.summary.FileWriter('graphs/word2vec_simple', sess.graph)

        for index in range(NUM_TRAIN_STEPS):
            try:
                loss_batch, _ = sess.run([loss, optimizer])
                total_loss += loss_batch
                if (index + 1) % SKIP_STEP == 0:
                    print('Average loss at step {}: {:5.1f}'.format(index, total_loss / SKIP_STEP))
                    total_loss = 0.0
            except tf.errors.OutOfRangeError:
                sess.run(iterator.initializer)
        writer.close()

def gen():
    yield from word2vec_utils.batch_gen(DOWNLOAD_URL, EXPECTED_BYTES, VOCAB_SIZE,
                                        BATCH_SIZE, SKIP_WINDOW, VISUAL_FLD)

def main():
    dataset = tf.data.Dataset.from_generator(gen,
                                (tf.int32, tf.int32),
                                (tf.TensorShape([BATCH_SIZE]), tf.TensorShape([BATCH_SIZE, 1])))
    word2vec(dataset)

if __name__ == '__main__':
    main()

코드가 조금더 길어졌지만, 이렇게 만듬으로써 이 모델을 재사용하기 쉬워졌다.

How to structure yout TensorFlow model

TensorFlow로 모델을 만드는 흐름에 대해서 다시 얘기해보자. 대부분의 코드들은 다음의 구조를 가질 것이다.

Phase1: assemble your graph

데이터 불러오기(tf.data or placeholder)
파라미터 정의
inference 모델 정의
loss 함수 정의
optimizer 정의

Phase2: execute the computation

모든 변수 초기화
데이터 iterator, feed 초기화
inference 모델 실행(각 input에 대해 학습한 결과 계산)
cost계산
파라미터 갱신

대부분 위의 흐름을 크게 벗어나지 않을 것이다.

word2vec 모델을 TensorBoard로 그래프를 보면 다음과 같이 나온다.

그래프를 보면 노드들이 다 흩어져 있는 것을 볼 수 있다. 만약 word2vec보다 조금 더 복잡한 모델이라면 그래프를 보기가 매우 어려울 것이다. 그렇다면 이런 그래프를 좀더 보기좋게 비슷한 것들끼리 그룹화를 할 수 있다면 어떨까? tf.name_scope를 사용하면 쉽게 grouping을 할 수 있다.

tf.name_scope는 다음과 같이 사용할 수 있다.

with tf.name_scope(name_of_that_scope):
	# declare op_1
	# declare op_2
	# ...

이전의 전체 python 코드를 보면 name_scope로 묶여있는 것을 볼 수 있다. 이렇게 묶은 후 TensorBoard로 그래프를 보면 아래와 같이 좀 더 명확하게 보기 쉽다.

Variable Scpoe

TensorFlow를 사용하다보면 name_scope와 variable_scope를 언제 구분해서 사용하는지 의문이 들 때가 있다. 이번에는 variable_scope에 대해서 알아보자.

두 개의 input을 받고, 2 hidden layer를 가지는 신경망을 생각해보자. 그러면 아래와 같이 Neural Network를 정의하고 사용할 것이다.

def two_hidden_layers(x):
    assert x.shape.as_list() == [200, 100]
    w1 = tf.Variable(tf.random_normal([100, 50]), name="h1_weights")
    b1 = tf.Variable(tf.zeros([50]), name="h1_biases")
    h1 = tf.matmul(x, w1) + b1
    assert h1.shape.as_list() == [200, 50]  
    w2 = tf.Variable(tf.random_normal([50, 10]), name="h2_weights")
    b2 = tf.Variable(tf.zeros([10]), name="h2_biases")
    logits = tf.matmul(h1, w2) + b2
    return logits

logits1 = two_hidden_layers(x1)
logits2 = two_hidden_layers(x2)

TensorFlow는 함수를 실행할 때 마다 다른 variable집합을 만든다. 따라서 위의 two_hidden_layers()를 호출할 때마다 get_variable이 실행되서 새로운 variable을 만들 것이다. 따라서 중복으로 생성하기 때문에 아래와 같은 error message가 나온다.

ValueError: Variable h1_weights already exists, disallowed. Did you mean to set reuse=True or reuse=tf.AUTO_REUSE in VarScope?

이런 Variable의 중복을 방지하기 위해 VarScope를 사용한다.

def fully_connected(x, output_dim, scope):
    with tf.variable_scope(scope) as scope:
        w = tf.get_variable("weights", [x.shape[1], output_dim], initializer=tf.random_normal_initializer())
        b = tf.get_variable("biases", [output_dim], initializer=tf.constant_initializer(0.0))
        return tf.matmul(x, w) + b

def two_hidden_layers(x):
    h1 = fully_connected(x, 50, 'h1')
    h2 = fully_connected(h1, 10, 'h2')

with tf.variable_scope('two_layers') as scope:
    logits1 = two_hidden_layers(x1)
    scope.reuse_variables()
    logits2 = two_hidden_layers(x2)

위와 같이 작성하면 중복 error가 발생하지 않는다.

Graph collections

모델을 만들 때 variable을 graph의 서로 다른 부분에 같이 넣는 상황이 있을 수 있다. tf.get_collection을 사용하면 특정 variable 모음에 접근할 수 있게 한다.

tf.get_collection(
    key,
    scope=None
)

Default로 모든 variabls은 tf.GraphKeys.GLOBAL_VARIABLES에 들어가 있다. ‘my_scope’의 모든 variable들을 사용하려면 다음과 같이 사용할 수 있다.

tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='my_scope')

만약에 Variable중에서 옵션 중 trainable=True로 설정한 변수들 사용하고 싶으면, tf.GraphKeys.TRAINABLE_VARIABLES collection을 사용하면 된다.

Manage experiments

우리는 앞서 word2vec을 적은 데이터셋으로 만들어보고 결과도 나름 잘나오는 것을 확인했다. 하지만 실제로는 더 많은 데이터셋이 필요하고, 따라서 시간도 훨씬 많이 걸릴 것이다. 복잡한 모델일 수록 학습에 필요한 시간은 급격히 늘어날 것이다. 예를 들어 기계번역 분야는 하루정도는 최소 학습시켜야 하고 경우에 따라 더 많이 학습을 해야 한다.

이렇게 몇일씩 걸리는 모델을 학습하면 모델이 학습이 끝나기 전까지는 우리는 전혀 결과를 알 수 없다. 심지어 중간에 컴퓨터에 문제라도 발생하게 되면 결과를 확인조차 할 수 없다.

그리고 또 하나의 문제점은 모델에 대해서 실험할 때 여러 요인들을 바꿔가며 실험하는데 이러한 요소들에 따른 비교를 하기가 어렵다.

따라서 이번에는 우리가 모델을 실험할 때 사용할 수 있는 몇가지 기능들에 대해서 알아보도록 한다. 알아볼 것들은 tf.train.Saver(), TensorFlow’s random state, visualization에 대해서 알아보도록 할 것이다.

tf.train.Saver()

tf.train.Saver()를 사용하면 주기적으로 우리의 모델의 파라미터값들을 저장할 수 있다. graph의 변수들을 binary파일로 저장한다. 이 Class의 save함수는 다음과 같이 구성된다.

tf.train.Saver.save(
    sess,
    save_path,
    global_step=None,
    latest_filename=None,
    meta_graph_suffix='meta',
    write_meta_graph=True,
    write_state=True
)

예를 들어서 만약에 1000 step마다 변수들을 저장하고 싶다면 아래와 같이 작성하면 된다.

saver = tf.train.Saver()

with tf.Session() as sess:

    for step in range(training_steps):
	sess.run([optimizer])
	if (step + 1) % 1000 == 0:
	   saver.save(sess, 'checkpoint_directory/model_name', global_step=global_step)

보통 흔히 쓰는 말로 graph의 변수를 저장하는 step을 ‘checkpoint’라 표현한다. 코드를 보면 ‘global_step’이라는 변수가 새로 나와있는데, 이 값을 설정해주면 학습과정을 좀 더 명확히 이해할 수 있어 좋다. 선언시에는 학습이 되지 않도록 trainable=False로 지정하고 0으로 초기화한다.

global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')

그리고 global_step은 학습이 진행될 때마다 점점 증가해야 되는데 따로 연산을 만들 필요없이 optimizer에 옵션으로 넣어주면 자동으로 증가한다.

optimizer = tf.train.GradientDescentOptimizer(lr).minimize(loss,global_step=global_step)

저장해둔 checkpoint를 복구하기 위해서는 saver.restore()함수를 사용한다.

saver.restore(sess, 'checkpoints/skip-gram-10000')

checkpoint들이 저장되어 있는 directory에서 가장 최근의 checkpoint를 사용하고 싶으면 아래와 같이 작성하면 자동으로 가장 최신의 checkpoint를 찾을 수 있다.

ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/checkpoint'))
if ckpt and ckpt.model_checkpoint_path:
     saver.restore(sess, ckpt.model_checkpoint_path)

따라서 모델을 만들 때 우선 checkpoint가 있는지 확인을 하고 있다면 그 checkpoint부터 다시 학습을 시작하면 된다. 따라서 기존의 word2vec 코드에서 checkpoint를 확인하고 사용하는 부분을 추가하면 다음과 같다.

saver = tf.train.Saver()

initial_step = 0
utils.safe_mkdir('checkpoints')

with tf.Session() as sess:
    sess.run(self.iterator.initializer)
    sess.run(tf.global_variables_initializer())

    # if a checkpoint exists, restore from the latest checkpoint
    ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/checkpoint'))
    if ckpt and ckpt.model_checkpoint_path:
        saver.restore(sess, ckpt.model_checkpoint_path)

    writer = tf.summary.FileWriter('graphs/word2vec' + str(self.lr), sess.graph)

    for index in range(num_train_steps):
        try:
            sess.run(self.optimizer)
            # save the model every 1000 steps
            if (index + 1) % 1000 == 0:
                saver.save(sess, 'checkpoints/skip-gram', index)
        except tf.errors.OutOfRangeError:
            sess.run(self.iterator.initializer)

    writer.close()

기본적으로는 tf.Saver.save를 사용하면 모든 변수가 자동으로 저장된다. 보통은 이 방법을 사용하기를 추천하지만, 경우에 따라 몇개의 변수만 따로 저장하고 싶은 경우에도 사용할 수 있다. 특정 변수를 list 혹은 dictionary 형태로 Saver 객체의 인자로 설정하면 그 변수들만 저장된다. 아래의 예시를 참고하자.

v1 = tf.Variable(..., name='v1')
v2 = tf.Variable(..., name='v2')

saver = tf.train.Saver({'v1': v1, 'v2': v2})

saver = tf.train.Saver([v1, v2])

saver = tf.train.Saver({v.op.name: v for v in [v1, v2]})

tf.summary

보통 우리는 matplotlib을 사용해서 우리의 losses, accuracy를 시각화했는데, TensorFlow를 사용하면 그럴 필요가 없다. TensorBoard를 활용하면 우리의 요약된 자료들을 쉽게 시각화 해준다.

보통 시각화를 많이하는 값인 loss, average loss, accuracy를 시각화를 해보자. 시각화는 scalar plot, histogram, image 형태 모두 가능하다. 우선은 우리가 사용할 값들을 summary operation을 사용한뒤 하나의 namescope로 정의한다.

def _create_summaries(self):
     with tf.name_scope("summaries"):
            tf.summary.scalar("loss", self.loss)
            tf.summary.scalar("accuracy", self.accuracy)            
            tf.summary.histogram("histogram loss", self.loss)
            # because you have several summaries, we should merge them all
            # into one op to make it easier to manage
            self.summary_op = tf.summary.merge_all()

summary는 하나의 연산(operation)이므로 session으로 실행해줘야 한다.

loss_batch, _, summary = sess.run([model.loss, model.optimizer, model.summary_op],
                                  feed_dict=feed_dict)

Filewriter를 통해 summary를 write하면 TensorBoard를 통해 확인할 수 있다.

writer.add_summary(summary, global_step=step)

이제 TensorBoard를 명령 프롬프트로 실행시킨 후 http://localhost:6006 을 들어가보면 다음과 같이 확인 할 수 있다.

graph 폴더에서 두개의 sub-폴더를 만들어서 summary들을 저장하면 여러 모델 혹은 여러 하이퍼파라미터들에 따른 비교를 할 수 있다.

마지막으로 image로 표현하는 방법은 다음의 함수를 사용한다.

tf.summary.image(name, tensor, max_outputs=3, collections=None)

Control randomization

텐서플로우를 사용하다 보면, Random한 값을 사용해야 할 때가 많이 있을 것이다. random 값을 가질 수 있는 방법은 여러가지 있는데, 이런 random 값을 어느정도 제어할 수 있는 방법이 있다. seed를 사용하는 것인데 크게 두 가지 정도로 구분되어 사용된다.

random seed in operation level

operation 단계에서 random seed 를 할당하는 방법이다. 아래의 여러 예들을 보며 사용 방법을 익혀보자.

c = tf.random_uniform([], -10, 10, seed=2)

with tf.Session() as sess:
	print sess.run(c) # >> 3.57493
	print sess.run(c) # >> -5.97319

c = tf.random_uniform([], -10, 10, seed=2)

with tf.Session() as sess:
	print sess.run(c) # >> 3.57493

with tf.Session() as sess:
	print sess.run(c) # >> 3.57493

c = tf.random_uniform([], -10, 10, seed=2)
d = tf.random_uniform([], -10, 10, seed=2)

with tf.Session() as sess:
	print sess.run(c) # >> 3.57493
	print sess.run(d) # >> 3.57493

random seed at graph level with tf.Graph.seed

만약 a.py와 b.py 두 파일이 똑같이 아래와 같은 코드로 구성되었을 때 실행시키면 어떻게 되는지 알아보자.

import tensorflow as tf

tf.set_random_seed(2)
c = tf.random_uniform([], -10, 10)
d = tf.random_uniform([], -10, 10)

with tf.Session() as sess:
	print sess.run(c)
	print sess.run(d)

$ python a.py
>> -4.00752
>> -2.98339

$ python b.py
>> -4.00752
>> -2.98339

이와 같이 seed를 graph 단계에서 주면 다른 파일이더라도 같은 값을 가진다.

Autodiff (how TensorFlow takes gradients)

텐서플로우는 자동 미분기능을 제공하는데, 우리가 명시적으로 사용하기 위한 함수도 존재한다. tf.gradients()를 사용하면 우리가 원하는 함수를 우리가 정한 변수로 미분할 수 있다. 함수는 아래와 같이 구성된다.

tf.gradients(ys, xs, grad_ys=None, name='gradients', colocate_gradients_with_ops=False, gate_gradients=False, aggregation_method=None)

ys는 미분할 함수이고, xs로 미분을 하겠다는 것이다. 그리고 여러 변수로 미분을 하거나 chain rule을 통해 미분도 가능하다. 아래의 예제를 보자.

x = tf.Variable(2.0)
y = 2.0 * (x ** 3)

grad_y = tf.gradients(y, x)
with tf.Session() as sess:
	sess.run(x.initializer)
	print sess.run(grad_y) # >> 24.0

x = tf.Variable(2.0)
y = 2.0 * (x ** 3)
z = 3.0 + y ** 2

grad_z = tf.gradients(z, [x, y])
with tf.Session() as sess:
	sess.run(x.initializer)
	print sess.run(grad_z) # >> [768.0, 32.0]
# 768 is the gradient of z with respect to x, 32 with respect to y

CS20(TensorFlow) Lecture Note (4): Eager execution and interface

2018-08-16T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

4. Eager execution and interface

이때까지의 강의를 통해 TensorFlow는 크게 두개의 흐름으로 구성된다는 것을 배웠다.

assembling the computation graph
executing that graph

위와 같이 그래프를 구성하고, 실행하는 것이 구분되어 있었다. 하지만 파이썬의 구동과 같이 TensorFlow도 imperatively하게 실행될 수 있다면 어떨까? 가능하다면 TensorFlow 모델을 만드는데 있어서 직관적이고 디버깅도 쉬워질 것이다.

TensorFLow의 eager 모드를 통해 TensorFlow도 imperatively하게 작성할 수 있다.

Eager execution

Eager execution에 대한 소개는 다음과 같다.

GPU가속과 자동 미분계산을 지원하는 수치 계산을위한 넘파이를 기본으로 하는 라이브러리이다.
머신러닝 연구와 실험을 위한 유연한 플랫폼이다.

Eager모드의 핵심 장점은 다음과 같다.

Eager 모드는 파이썬 디버깅 툴에 적합하다.(pdb.set_trace())
즉각적인 에러 report
파이썬 데이터 구조를 사용할 수 있다.
사용이 쉽고, Pythonic하다.

그렇다면 eager모드를 사용하는 기본적인 방법을 보자, 단 몇줄로 쉽게 사용 가능하다.

import tensorflow as tf
import tensorflow.contrib.eager as tfe
tfe.enable_eager_execution()

위의 문장만 사용하면 eager모드로 코딩이 가능하다. 따라서 파이썬 자료형으로도 아래와 같이 작성할 수 있다.

x = [[2.]]
m = tf.matmul(x, x)

print(m) # Session이 필요없다.

예제만 보더라도 기존의 Operator, Variable, Session을 사용할 때보다 훨씬 직관적이고 쉽다. 아직은 eager모드에서 기존의 모드처럼 많은 기능들을 제공하지는 않지만 점점 추가될 예정이다.

eager모드로 미분을 하는 방법도 매우 간단하다. 정의된 연산을 미분 함수에 넣으면 자동으로 미분을 계산해준다. 아래의 예시를 보자.

def square(x):
  return x ** 2

grad = tfe.gradients_function(square)

print(square(3.))    # tf.Tensor(9., shape=(), dtype=float32)
print(grad(3.))     # [tf.Tensor(6., shape=(), dtype=float32))]

그렇다면 이제 lecture 4에서 만들었던 Linear regression 모델을 eager모드로 만들어 보자.

우선은 eager를 포함해 필요한 라이브러리를 임포트한다.

import time

import tensorflow as tf
import tensorflow.contrib.eager as tfe
import matplotlib.pyplot as plt

import utils

2장에서 했던 방법 그대로 데이터를 불러오자. 그리고 tfe.enable_eager_execution()를 통해 eager를 실행한다.

DATA_FILE = 'data/birth_life_2010.txt'

tfe.enable_eager_execution()

# Read the data into a dataset.
data, n_samples = utils.read_birth_life_data(DATA_FILE)
dataset = tf.data.Dataset.from_tensor_slices((data[:,0], data[:,1]))

이후 우리가 사용할 parameter를 정의한다.

w = tfe.Variable(0.0)
b = tfe.Variable(0.0)

이제 우리가 사용할 linear모델을 만들고, 사용할 loss함수를 정의한다. loss는 square와 huber 두 가지 모두 정의한다.

def prediction(x):
  return x * w + b

def squared_loss(y, y_predicted):
  return (y - y_predicted) ** 2  

def huber_loss(y, y_predicted, m=1.0):
  # 기본 m 값은 1.0으로 준다.
  t = y - y_predicted
  return t ** 2 if tf.abs(t) <= m else m * (2 * tf.abs(t) - m)  

이제 optimizer를 포함해서 하나씩 뽑아서 loss를 구하는 함수와 학습과정들을 모두포함해서 하나의 함수로 만든다.

def train(loss_fn):
  print('Training; loss function: ' + loss_fn.__name__)
  optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

  def loss_for_example(x, y):
    return loss_fn(y, prediction(x))

  grad_fn = tfe.implicit_value_and_gradients(loss_for_example)

  start = time.time()
  for epoch in range(100):
    total_loss = 0.0
    for x_i, y_i in tfe.Iterator(dataset):
      loss, gradients = grad_fn(x_i, y_i)
      optimizer.apply_gradients(gradients)
      total_loss += loss
    if epoch % 10 == 0:
      print('Epoch {0}: {1}'.format(epoch, total_loss / n_samples))
  print('Took: %f seconds' % (time.time() - start))

마지막으로 학습함수를 실행시키고 시각화를 위해 matplotlib을 사용한다.

train(huber_loss)
plt.plot(data[:,0], data[:,1], 'bo')
plt.plot(data[:,0], data[:,0] * w.numpy() + b.numpy(), 'r',
         label="huber regression")
plt.legend()
plt.show()

코드를 보면 기존의 방법과는 달리 좀 더 파이썬스럽고 직관적으로 보인다. 이전 lecture에서 placeholder와 data 둘다 알아보고 익힌것 처럼 session을 통한 TensorFlow 코드와 eager를 통한 TensorFlow 코드 모두 익히도록 하자.

그렇다면 Eager는 어떤 경우에 사용하는 것이 좋을까? 다음의 경우에 사용하는 것이 이점이 있다.

연구자들이 사용하기에 적합하다.
유연한 Framework을 원하는 사람
새로운 모델을 만드는 사람들
TensorFlow를 새롭게 접하는 사람들

Eager모드의 장점인 디버깅이 쉽다는 점 때문에 위와 같은 경우에는 eager모드를 사용하는 것이 더욱 적합할 것이다.

하지만 모든 경우에 eager모드를 사용할 수 있는 것이 아니고, 1.5 버전 이상의 TensorFlow에서만 사용할 수 있다.

eager모드에 대해서 더 자세한 내용은 user guide를 참고하자.

CS20(TensorFlow) Lecture Note (3): Linear and Logistic Regression

2018-08-15T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

3. Linear and Logistic Regression

이번 Lecture는 프로젝트로 진행된다. 앞서 배웠던 operation, sessiom, variable, constant 등을 이용해서 두개의 프로젝트를 진행한다.

첫 번째는 birth rate를 통해 life expectancy를 예측하는 linear regression 모델을 만드는 것이다.

두 번째는 MNIST 손글씨 데이터를 logistic regression을 통해 예측하는 모델을 만든다.

두 모델의 다른 점은 linear와 logistic의 차이뿐만 아니라 구현과정에서 데이터를 읽는 방식을 다르게 진행했다. 첫 번쨰 모델에서는 일반적이고 이전에 배웠던 방법인 tf.placeholder를 이용해서 데이터를 받을 것이고, 두 번째에서는 최근의 방법인 tf.data를 통해서 데이터를 다룰 것이다. 두 방법모두 익히는 것이 좋으므로 모델을 만들면서 차이와 구현방법에 대해서 알아보도록 하자.

Linear regression: Predict life expectancy from birth rate

제목에서 나와 있듯이 birth rate를 통해서 life expectancy를 예측하는 모델을 만들 것이다. 다르게는 두 수치간의 관계를 찾는다고 생각하도 된다. 우선은 우리가 알아볼 데이터에 대해서 알아보자.

X = brith rate, (Type:float)
Y = life expectancy, (Type:float)
총 190개의 데이터

위 데이터를 가지고 모델을 만들 것이다. 우리는 두 수치간의 관계가 linear하다고 생각하고, linear한 모델을 만들 것이다. 즉 아래의 식으로 모델링을 한다.

$Y=wX+b$

이제 우리는 데이터를 통해 w,b를 학습시킬것이다. 이제 코드를 살펴보자. 전체 코드는 github을 참고하자.

우선은 우리가 필요한 라이브러리들을 import한다. utils은 데이터 다운로드, 데이터 읽기등을 위해 미리 만들어 놓은 utils.py 파일이다.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2' # 로그 레벨, warning이상만 logging
import time

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

import utils

데이터를 읽어오자. utils의 read_birth_life_data 함수를 사용하면된다.

DATA_FILE = 'data/birth_life_2010.txt'

data, n_samples = utils.read_birth_life_data(DATA_FILE)

이제는 데이터를 받을 X, Y를 정의해야 한다. 여기서는 placeholder를 사용한다.

X = tf.placeholder(dtype=tf.float32)
Y = tf.placeholder(dtype=tf.float32)

그리고 linear regression 모델의 파라미터인 w와 b를 get_variable함수로 생성한다. 처음에는 모두 0으로 초기화 하자.

w = tf.get_variable(name ='weight', shape=(), initializer=tf.zeros_initializer())
b = tf.get_variable(name = 'bias', shape=(), initializer=tf.zeros_initializer())

참고로 여기서 w,b,X,Y 모두 scalar값이다. 따라서 shape는 shape = ()으로 설정하거나 shape = []으로 설정하면 된다.

이제 우리의 모델을 정의한다. linear 모델이므로 아래와 같이 작성한다.

Y_predicted = X * w + b

그리고 loss 와 optimizer를 정해줘야 한다.

loss = tf.square(Y - Y_predicted, name='loss')
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(loss)

마지막으로 학습시간 측정을 위해 시작 시간을 측정한다.

start = time.time()

이제 필요한 것을 다 선언했으므로 Session을 통해 실행하자.

with tf.Session() as sess:

    # 모든 변수 일괄 초기화
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./graphs/linear_reg', sess.graph)

    # 총 100에폭
    for i in range(100):
        total_loss = 0
        for x, y in data:
            # Execute train_op and get the value of loss.
            # Don't forget to feed in data for placeholders
            _, loss_ = sess.run([optimizer, loss], feed_dict={X: x, Y: y})
            total_loss += loss_

        print('Epoch {0}: {1}'.format(i, total_loss/n_samples))

    # close the writer when you're done using it
    writer.close()

    # Step 9: output the values of w and b
    w_out, b_out = sess.run([w, b])

각 에폭마다 average loss 값을 출력하고 모든 학습이 끝나면 w와 b값을 저장한다. 그리고 학습에 소요된 시간과 마지막 loss, w, b 값을 모두 출력한다.

print('Took: %f seconds' %(time.time() - start))
print('last value of loss, w, b: {0}, {1}, {2}'.format(total_loss/n_samples, w_out, b_out))

Control flow: Huber loss

간단한 모델인 만큼 구현도 간단하게 끝났다. 다음 모델로 넘어가기 전에 Loss함수에 대해서 얘기해보자. 여기 모델에서는 일반적인 Square loss 함수를 사용했다. 다른 loss를 사용하려 하는데, tensorflow에서 제공하는 함수가 없어 직접 정의해서 사용해야 한다고 하자. 우리가 사용할 loss함수는 Huber loss로 수식은 다음과 같이 구성된다.

$L_\delta(y,f(x))= \begin{cases} \begin{align*} &\frac{1}{2}(y-f(x))^2&\text{for}~\vert y-f(x)\vert\le\delta,\\ &\delta\vert y-f(x)\vert-\frac{1}{2}\delta^2&\text{otherwise} \end{align*} \end{cases}$

조건에 따라 함수가 달라지는 경우이다. 이럴 경우에는 어떻게 해야 할까, 만약 파이썬 코드로 짠다면, 즉 Pythonic하게 짠다면 if문을 사용해야 할것이다. TensorFlow도 다음과 같은 경우에 사용할 수 있는 함수가 있다. tf.cond함수이다. 함수의 구성은 다음과 같다.

tf.cond(pred, true_fn=None, false_fn=None, ...)

즉 pred 조건식에 따라 true이면 ture_fn함수를 사용, false이면 false_fn함수를 사용한다. 따라서 huber loss는 다음과 같이 tf.cond를 사용해서 정의할 수 있다.

def huber_loss(label, prediction, delta=14.0):
    residual = tf.abs(label - prediction)
    def f1(): return 0.5*tf.square(residual)
    def f2(): return delta*residual-0.5*tf.square(delta)
    return tf.cond(residual < delta, f1,f2)

cond함수는 true, false의 경우로 구분하는데 많은 case로 나누는 경우는 tf.case함수를 사용하면 된다.

tf.data

위의 코드에서는 데이터를 사용할 때 placeholder를 사용했다. 하지만 placeholder는 오래된 방식이고, 이 방식에 대해서는 다양한 의견이 있다. 찬성의 의견은 data 처리를 TF 밖에서 쉽게 할 수 있다는 점이고, 단점은 데이터 처리를 single쓰레드로 처리해야 하고 데이터 병목현상으로 느려진다는 점이다. 따라서 이러한 문제를 해결하기 위한 것이 tf.data이다.

tf.data를 사용하는 방법에 대해서 알아보자.

tf.data.Dataset.from_tensor_slices((feature, labels))

여기서 feature와 labels은 Tensor 자료형이여야 한다. 하지만 tensor 자료형은 numpy 자료형과 같으므로 numpy 자료형을 넣어도 된다. 즉 위의 모델에서 데이터를 tf.data로 읽는다면 다음과 같이 작성하면 된다.

data, n_samples = utils.read_birth_life_data(DATA_FILE)

dataset = tf.data.Dataset.from_tensor_slices((data[:,0], data[:,1]))

그리고 tf.data.Dataset에는 데이터 파일을 Tensorflow file format parser로 바로 읽을 수 있는 여러 방법이 있다.

tf.data.TextLineDataset(filenames) 파일의 각 줄을 하나의 데이터로 읽는다. 주로 csv파일 읽을 때나 기계번역 분야의 데이터에서 많이 사용된다.
tf.data.FixedLengthRecordData(filenames) 고정된 길이의 데이터에서 주로 사용된다. 정해진 길이 만큼 하나의 데이터로 받는다. 자주 사용되는 곳 또한 고정된 길이로 구성된 데이터에서 많이 사용된다. 예를 들면 CIFAR 데이터 혹은 ImageNet 데이터와 같은 것들을 읽을 때 사용한다.
tf.data.TFRecordDataset(filenames) tfrecord 형식의 데이터에 사용한다.

데이터를 읽는 방법을 알아봤다. 이제는 데이터를 사용할 때를 살펴보자. 기존의 코드에서는 for문을 통해서 데이터의 값을 하나씩 뽑아서 사용했다. tf.data에서는 iterator를 사용하면 더욱 쉽게 데이터를 하나씩 사용할 수 있다.

iterator = dataset.make_one_shot_interator()
X, Y = iterator.get_netx()

이러한 방식으로 사용하면 된다. dataset.make_one_shot_interator()는 데이터를 하나씩 사용할 떄 사용하는 방식이고 batch방식등 여러 기능을 제공한다. 위와 같이 정의한 data를 session에서 다음과 같이 while문으로 사용하면 된다.

sess.run(iterator.initializer) # initialize the iterator
    total_loss = 0
    try:
        while True:
            _, l = sess.run([optimizer, loss])
            total_loss += l
    except tf.errors.OutOfRangeError:
        pass

tf.data를 사용하는 것은 placeholder를 사용하는 것보다 32.4% 정도 빠르다고 알려져 있다. 따라서 tf.data를 사용하는 것을 추천한다.

Optimizer

Optimizer를 사용하는 방법은 매우 간단하다. 단 몇줄의 코드만으로도 복잡한 구성의(미분, update) optimizer를 쉽게 사용할 수 있다.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(loss)
sess.run([optimizer])

optimizer를 사용하면 미분값 계산, update 등을 자동으로 수행한다. 따라서 관련된 모든 variable에 적용이되는데, 경우에 따라서 update를 안해야하는 variable이 있을 수 있다. 그러한 variable의 경우에는 option으로 trainable=False만 지정해주면 train 되지 않도록 쉽게 설정 가능하다

그리고 위에서 사용한 GD opmizer뿐만 아니라 다른 다양한 optimizer또한 tensorflow 함수로 제공한다. 아래는 optimizer의 리스트이다.

tf.train.Optimizer
tf.train.GradientDescentOptimizer
tf.train.AdadeltaOptimizer
tf.train.AdagradOptimizer
tf.train.AdagradDAOptimizer
tf.train.MomentumOptimizer
tf.train.AdamOptimizer
tf.train.FtrlOptimizer
tf.train.ProximalGradientDescentOptimizer
tf.train.ProximalAdagradOptimizer
tf.train.RMSPropOptimizer

다양한 optimizer에 대해서 Sebastain Ruder의 블로그에 정리한 글이 있는데 내용의 일부만 인용하면 다음과 같다.

“RMSprop is an extension of Adagrad that deals with its radically diminishing learning rates. It is identical to Adadelta, except that Adadelta uses the RMS of parameter updates in the numerator update rule. Adam, finally, adds bias-correction and momentum to RMSprop. Insofar, RMSprop, Adadelta, and Adam are very similar algorithms that do well in similar circumstances. Kingma et al. [15] show that its bias-correction helps Adam slightly outperform RMSprop towards the end of optimization as gradients become sparser. Insofar, Adam might be the best overall choice.”

내용이 길지만 요약하면 결국 다음과 같다.

“Adam을 사용하자”

logistic Regression with MNIST

이번에는 MNIST 손글씨 데이터를 통해 손글씨 이미지를 보고 숫자를 예측하는 모델을 만들어 보도록 한다. MNIST데이터는 0~9까지의 숫자의 손글씨로 이루어져 있고, 각 이미지는 28x28 pixel로 이루어져 있다. 여기서는 28x28 이미지를 평평하게 1-d tensor(vector)로 만들어서 사용할 것이다. 데이터는 아래와 같은 형태이다.

이제 모델을 만들어 보자. 우선은 임포트부터 진행한다.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

import numpy as np
import tensorflow as tf
import time

import utils

다음으로는 우리가 사용할 값들을 정의한다.

learning_rate = 0.01
batch_size = 128
n_epochs = 30
n_train = 60000
n_test = 10000

그리고 데이터를 불러온 뒤 tf.data활용해 data를 불러오고, batch사이즈로 나눠주자.

mnist_folder = 'data/mnist'
utils.download_mnist(mnist_folder) # 404 Not Found 에러 발생 시 unit의 download_mnist함수의 url 마지막에 '/' 추가
train, val, test = utils.read_mnist(mnist_folder, flatten=True)

train_data = tf.data.Dataset.from_tensor_slices(train)
train_data = train_data.shuffle(10000) # 선택
train_data = train_data.batch(batch_size)

test_data = tf.data.Dataset.from_tensor_slices(test)
test_data = test_data.batch(batch_size)

그리고 iterator를 만들고 초기화 방법을 정한다.

iterator = tf.data.Iterator.from_structure(train_data.output_types,
                                           train_data.output_shapes)
img, label = iterator.get_next()

train_init = iterator.make_initializer(train_data)	# initializer for train_data
test_init = iterator.make_initializer(test_data)	# initializer for train_data

모델의 파라미터인 w,b 를 생성한다. img 크기에 맞게 shape을 정해준다. 그리고 w는 평균 0, 표준편차 분산 0.01의 정규분포로 초기화하고, b는 0으로 초기화한다.

w = tf.get_variable(name='weight', shape=(784,10), initializer=tf.random_normal_initializer(0,0.01))
b = tf.get_variable(name='bias', shape=(1,10), initializer=tf.zeros_initializer())

logit과 softmax 함수를 정의하고 loss함수를 정의한다.

logits = tf.matmul(img,w) + b

entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=label, name='entropy')
loss = tf.reduce_mean(entropy, name = 'loss')

Optimizer는 Adam optimizer를 사용한다.

optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)

예측하는 연산과, 예측이 맞았는지 확인하는 것과 정확도 계산 연산을 정의한다.

preds = tf.nn.softmax(logits)
correct_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(label, 1))
accuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))

이제 Session을 통해 정의한 것들을 실행하자.

writer = tf.summary.FileWriter('./graphs/logreg', tf.get_default_graph())
with tf.Session() as sess:

    start_time = time.time()
    sess.run(tf.global_variables_initializer())

    # train the model n_epochs times
    for i in range(n_epochs):
        sess.run(train_init)	# drawing samples from train_data
        total_loss = 0
        n_batches = 0
        try:
            while True:
                _, l = sess.run([optimizer, loss])
                total_loss += l
                n_batches += 1
        except tf.errors.OutOfRangeError:
            pass
        print('Average loss epoch {0}: {1}'.format(i, total_loss/n_batches))
    print('Total time: {0} seconds'.format(time.time() - start_time))

    # test the model
    sess.run(test_init)			# drawing samples from test_data
    total_correct_preds = 0
    try:
        while True:
            accuracy_batch = sess.run(accuracy)
            total_correct_preds += accuracy_batch
    except tf.errors.OutOfRangeError:
        pass

    print('Accuracy {0}'.format(total_correct_preds/n_test))
writer.close()

참고로 위의 코드중에서 데이터를 suffle하는 것을 선택하도록 했는데, suffle을 안하고 실행시 정확도가 91.34%로 일정했는데, suffle을 하면 88~93%사이의 값으로 정확도가 변했다. 즉 suffle은 경우에따라 좋을 수도 있고 안좋을 수도 있다.

Seq2seq with attention: Neural Machine Translation by Jointly Learning to Align and Translate

2018-08-13T04:47:35+00:00

최근 NLP에서 많은 모델에서 사용되는 기술인 attention기법을 처음으로 도입한 논문인 Neural Machine Translation by Jointly Learning to Align and Translate에 대해 알아보도록 한다. 최초로 attention을 도입한 이 논문은 Seqeunce to seqeunce with attetion으로도 유명하다.

정확히는 이 논문은 Seqeunce to sequence를 처음으로 도입한 조경현 교수님의 Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation(참고: 블로그 글)에서의 문제점을 해결하기 위해 이어서 나온 논문이라 볼 수 있다.

이전 논문을 기억해보면 Encoder-Decoder구조는 RNN Encoder를 통해 가변길이의 sequence를 하나의 고정된 길이의 vector로 만든 후 다시 그 vector를 통해 가변길이의 output sequence로 만드는 구조였다. 하지만 여기서의 문제점은 중간의 하나의 vector로는 앞선 모든 sequence의 정보를 담기 어렵다는 것이였고, 따라서 이 논문에서의 attention 메커니즘을 통해 해결하려 한다.

이제 논문리뷰를 해보자.

Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation

논문의 저자는 KyunHyun Cho, Yoshua Bengio, Dzmitry Bahdanau로 원 논문은 링크를 참고하자.

Introduction

Neural machine translation(NMT)은 최근 기계번역 분야에서 부상된 분야이다. 기존의 통계적 기계 번역(SMT)와는 달리 NMT는 번역 성능을 올리기 위한 단일 신경망을 만드는 것을 목표로 한다. 최근 제안된 NMT 모델은 encoder-decoder 구조의 모델이다.

이 논문에서는 encoder-decoder 구조에서 중간의 fixed-size vector를 사용하는 것에 의해 병목현상이 일어날 것이라 추측했다. 실제로도 input sentence가 길어질수록 성능이 급격하게 떨어졌다. 따라서 이러한 문제를 해결하기 위해 이 구조를 확장시켜서 자동으로 문장에서 target 단어와 중요한 관계를 가지는 부분을 찾도록 할 것이다.

즉 align and translate를 같이 학습하는 encoder-decoder 모델을 만들 것이다. 매 time-step 마다 번역된 단어를 만들면서 source 문장에서의 관련된 정보를 가지는 것들의 위치를 찾는다.

이러한 접근법을 통해서 번역 성능을 매우 향상시킬 것이며, 긴 문장에도 높은 성능을 보여줄 것이다.

Background: Neural Machine translation

확률적인 관점에서 보면 번역은 아래의 수식의 $y$ 를 찾는 과정이다.

$\arg\max_{\mathbf{y}}p(\mathbf{y}\vert\mathbf{x})$

Nueral machine translation에서는 위 식의 확률을 최대화 하기 위해서 번역 데이터 쌍을 통해 파라미터를 학습한다. 최근에 많은 논문들이 이러한 Neural machine translation 모델들을 제안했는데, 이 모델들은 보통 두개의 부분으로 나뉜다. 첫 번째는 source 문장 $\mathbf{x}$ 를 encode하는 과정이고, 두 번째는 다시 target 문장 $\mathbf{y}$ 로 decode하는 과정이다.

이러한 구조를 가지는 모델들은 RNN을 base로 하고 있다. 따라서 RNN Encoder-Decoder라고도 불리는데, 이 구조를 조금 더 설명하자면, 우선 Encoder 과정에서는 input sequence에 대해서 encoding된 vector인 $\mathbf{c}$ 로 만든다.

$h_t=f(x_t,h_{t-1})$ $\mathbf{c}=q(\{h_1,...,h_{T_x}\})$

Decoder 과정은 주어진 context vector인 $\mathbf{c}$ 를 사용해서 다음 단어인 $y_{t'}$ 을 예측한다. 이러한 과정을 반복해서 전체 단어들인 ${y_1,...,y_{t'-1}}$ 을 예측한다. 즉 decoder는 다음의 확률로 해석될 수 있다.

$p(\mathbf{y}) = \prod^T_{t=1}p(y_t\vert \{y_1,...,y_{t-1}\},c)$

여기서 확률은 non-linear함수인 $g$에 대해 다음과 같이 정의된다.

$p(y_t\vert\{y_1,...,y_{t-1},c)=g(y_{t-1},s_t,c)$

Learning to align and translate

앞서 말한 것처럼 align 과 translation을 같이 학습하는 모델을 만들 것이다. 따라서 이러한 새로운 모델에는 두가지의 새로운 구조가 있다. 하나는 Bidirection RNN encoder이고, 또 하나는 디코딩 과정에서 source sentence를 검색하는 decoder이다. 아래의 그림은 전체적인 구조를 그림으로 나타낸 것이다.

Decoder: Genenral description

이전 section에서 정의한 조건부 확률을 다시 새롭게 정의한다.

$p(y_i\vert y_1,...,y_{i-1},\mathbf{x})=g(y_{y-1},s_i,c_i)$

여기서 새롭게 나온 $s_i$ 는 RNN의 hidden state이다. 다음과 같이 계산된다.

$s_i=f(s_{i-1}, y_{i-1}, c_i)$

우선은 이 방법은 기존의 encoder-decoder 방식과는 다르다. 여기서 $c_i$ 는 encoder의 $(h_1,...,h_{T_x})$ 에 의해 계산된다. 여기서 각각의 $h_i$ 는 i번째 단어 주변을 좀 더 focus한 정보를 가지고 있다.(이 부분에 대한 설명은 다음 section에서 자세히 설명한다)

따라서 context vector $c_i$ 는 각 $h_i$ 들에 weight들을 각각 곱해서 계산된다.

$c_i=\sum^{T_x}_{j=1}\alpha_{ij}h_j$

여기서 각 $h_j$ 에 대한 가중치인 $\alpha_{ij}$ 는 다음과 softmax의 형태로 계산된다.

$\alpha_{ij}=\frac{\exp(e_{ij})}{\sum^{T_x}_{k=1}\exp(e_{ik})}$

그리고 또 여기의 $e_{ij}$ 는 다음과 같다.

$e_{ij}=a(s_{i-1}, h_j)$

$e_{ij}$ 은 alignment model이라 부른다. 이 값은 j번째 input 주변의 정보들이 얼마나 i번째 output과 적합한지에 대한 점수를 나타낸다. 이 점수는 RNN의 hidden state인 $s_{i-1}$ 과 j번 째 annotation인 $h_j$ 에 의해 계산된다.

alignment model인 a는 하나의 feedforward neural network로 만들었으며, 다른 네트워크와 같이 학습되도록 만들었다. 기존의 machine translation에서는 alignment를 latent variable로 봤었는데, 여기서는 하나의 network의 variable이 된다.

따라서 두개의 network가 같이 학습되는 것인데, 학습과정에서 cost의 gradient는 backpropagation을 통해 두 network에 같이 사용된다.

그리고 그 전의 annotation( $h$ )들을 weighted sum 하는 것은 annotation의 기대값을 구하는 것이라 생각하면 된다. 즉 $\alpha_{ij}$ 를 target word $y_i$ 와 source word $x_j$ 에 대한 확률이라 생각하면, i번째 context vector $c_i$ 는 annotation의 기대값이 된다.

확률 값인 $\alpha_{ij}$ 와 거기에 사용된 energy인 $e_{ij}$ 는 annotation $h_j$ 의 $s_{j-1}$ 에 대한 중요도를 나타낸다.

이러한 구조를 통해 decoder는 attention 메커니즘을 가진다. 즉 decoder가 source sentence에서 집중해야 할 부분을 결정할 수 있게 한다.

Encoder: Bidirectional RNN for annotating sequences

일반적인 RNN 구조에서는 input sequence에 대해 순방향으로 차례대로 계산을 하게 된다. 그러자 여기에서는 annotation이 앞선 단어에 대한 정보 뿐만 아니라 이후에 오는 정보도 포함할 수 있도록 양방향의 RNN(bidirection RNN, BiRNN)을 사용했다. 그리고 이 BiRNN은 이미 음성 인식분야에서 성공적인 성과를 보여줬다.

BiRNN은 순방향(forward)와 역방향(backward) RNN, 두개의 RNN으로 구성된다. 먼저 순방향 RNN $\overset{\rightarrow}{f}$ 은 sequence를 처음부터 순서대로 읽고 forward hidden state $({\overset{\rightarrow}{f}}_1,...,{\overset{\rightarrow}{f}}_{T_x})$ 를 계산한다. 역방향 RNN $\overset{\leftarrow}{f}$ 는 sequence를 역방향으로 마지막부터 처음까지 읽고 backward hidden state $({\overset{\leftarrow}{f}}_1,...,{\overset{\leftarrow}{f}}_{T_x})$ 를 계산한다.

이제 각 단어 $x_j$ 에 대해서 foward hidden state와 backward hidden state를 concatenate해서 annotation $h_j$ 를 구한다.

$h_j=\big[{\overset{\rightarrow}{f}}^T_j;{\overset{\leftarrow}{f}}_j^T\big]$

이 방법을 통해 annotation $h_j$ 는 j번쨰 단어 앞뒤의 정보를 모두 포함할 수 있게 된다.

Experiment Settings

실험을 위한 데이터셋은 WMT’14 English-French corpora를 사용했다. 데이터에 대한 설명은 조경현 교수님의 paper review 글을 참고하자(blog).

그리고 data selection 방법을 통해 데이터의 size를 줄였고, 앞선 데이터의 monolingual data는 사용하지 않았다.

실험을 위해 두가지 모델을 학습 시켰다. 하나는 기존은 RNN Encoder-Decoder모델(RNNencdec)이고 나머지 하나는 이 글에서 소개한 모델(RNNsearch)이다. 두 모델을 각각 두번 학습 시켰는데, 한번은 문장 길이를 30으로 제한한 것이고(RNNencdec-30, RNNsearch-30), 두 번째는 문장 길이를 50(RNNencdec-50, RNNsearch-50)으로 제한시켰다.

RNNencdec와 RNNsearch 모두 encoder,decoder는 각각 1000개의 hidden unit을 가진다.

학습과정에서 minibatch SGD 알고리즘을 사용했으며, Adadelta를 사용해 파라미터 update를 했다. 각 SGD update는 80 크기의 mini-batch로 업데이트 되었다.

모델을 학습 한 이후에는 beam search를 이용해 번역을 진행했다. 이 과정 또한 앞선 모델의 설명에서 확인 할 수 있다.

Quantitative Results

우선은 위의 그래프를 보면 RNNencdec 모델의 경우 문장 길이가 길어 질 수록 BLUE 스코어가 확연히 떨어지는 것을 볼 수 있는데 RNNsearch-50 의 경우 문장의 길이가 길어 지더라도 지속적으로 높은 BLUE 스코어를 가진다.

Qualitative Analysis

위 그림은 각각의 단어에 대해 annotation $\alpha_{ij}$ 값을 grayscale로 나타낸 그림이다. 그림을 보면 각각 단어가 매칭되는 부분에서 annotation이 높은 값을 가지는 것을 알 수 있고, 정확히 대칭되는 위치가 아니라 앞 뒤의 위치에서도 매칭될 수 있는 모습을 볼 수 있다.

그리고 논문에는 긴 문장의 영어를 번역했을 때 나온 불어가 굉장히 잘 번역되었다고 하는데, 이 부분은 불어를 잘 모르기 때문에 생략한다.

긴글 읽어주셔서 감사합니다. 오역 및 잘못된 내용이 있을 수 있습니다. 잘못된 부분 혹은 이해가 잘 안되는 부분은 댓글 혹은 메일로 말씀해주시면 감사하겠습니다!

Seq2seq (2): Sequence to Sequence Learning with Neural Networks

2018-08-13T04:47:35+00:00

최초의 Seq2Seq 개념을 도입한 논문에 대해서 알아보았다. 이번에는 Sequence to sequence 개념을 사용해 일반적으로 최초의 Neural Machine Translation 모델로 알려져 있는 Google의 Sequence to Sequence Learning with Neural Networks에 대해서 알아보자.

Sequence to Sequence Learning with Neural Networks

Introduction

Deep Neural Network는 여러 분야에서 많은 성과를 보여줬다. 많은 분야에서 이미 증면된 DNN은 유연하고 강력함에도 불구하고, input과 target이 고정된 dimension의 vector인 경우의 문제에만 사용할 수 있었다. 이러한 점이 DNN의 심각한 한계였다. 많은 중요한 문제는 input과 target이 길이에 대한 정보가 미리 주어지지 않은 sequence이기 때문이다. 예를 들어 QA(Question Answering)문제도 주어진 가변길이의 sequence를 answer에 대한 가변길이 seqeunce로 바꾸는 문제이다.

따라서 이 논문에서는 LSTM을 활용해서 sequence에서 sequence로 가는 구조를 소개한다. 아래의 그림은 모델의 구조를 보여준다.

모델에 대해서 자세히 알아보자.

The Model

Recurrent Neural Network는 sequence의 일반적인 feedforward neural network이다. 주어진 input sequence $(x_1,...,x_n)$ 에 대해, RNN은 아래의 수식을 반복하면서 output sequence $(y_1,...,y_T)$ 를 계산한다.

$\begin{align*} h_t&=\sigma(\mathbf{W}^{hx}x_t+\mathbf{W}^{hh}h_{t-1})\\ y_t&=\mathbf{w}^{yh}h_t \end{align*}$

RNN을 통해 input sequence를 앞선 시간 정보를 포함한 output seqeunce으로 쉽게 mapping 할 수 있다. 하지만 input의 길이와 output길이가 다르고 두 길이가 간단한 관계로 이루어 지지 않은 경우에는 RNN을 적용하기 어렵다.

이를 해결할 간단한 전략은 input sequence를 RNN을 통해 고정된 길이의 vector로 만든 후에 다시 그 vector를 RNN을 통해 우리가 원하는 target sequence를 구하는 방법이다.(Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation와 유사한 방식이다) 단순한 RNN을 통해서도 이러한 전략을 구현할 수 있지만, 중요한 문제점은 RNN은 Long-term에 대한 정보를 포함하지 않는다는 것이다. 따라서 Long Short-Term Memory(LSTM)을 사용해서 이러한 long-term에 대한 정보를 잡아 낼 것이다.

여기서 LSTM의 최종적인 목표는 input sequence에 대한 output sequence의 조건부 확률 $p(y_1,...,y_{T'}\vert x_1,...,x_T)$ 를 구하는 것이다. 따라서 위의 전략대로 우선 주어진 input sequence를 통해 고정된 길이의 vector representation $v$ 를 먼저 구한다. 여기서 벡터 $v$ 는 첫 RNN의 마지막 hidden state의 값이 된다. 그리고 다시 LSTM을 통해 $y_1,...,y_{T'}$ 에 대한 확률을 게산한다. 즉 아래의 식과 같이 계산한다.

$p(y_1,...,y_{T'}\vert x_1,...,x_T)=\prod^{T'}_{t=1}p(y_t\vert v,y_1,...,y_{t-1})$

위 식에서 우항의 $p(y_t\vert v,y_1,...,y_{t-1})$ 은 전체 vocabulary의 단어를 통해 softmax값을 계산해서 구한다. 문장이 끝난 지점에는 “"라는 토큰을 사용해 문장이 끝났다는 정보를 주고 그 지점부터 다시 output의 계산을 시작한다. 즉 위의 그림을 보면 먼저 LSTM은 "A", "B", "C", ""를 먼저 계산한다 그리고 마지막의 hidden state값을 통해 "W", "X", "Y", "Z", "" 에 대한 확률을 계산한다.

실제 모델은 위의 설명과 세가지 방법이 다르다. 첫 번째로는 input sequence와 output sequence에 대해 두개의 다른 LSTMs를 사용했다. 두 번째로는 deep한 LSTM의 성능이 더 뛰어난 것을 확인한 후 4개의 layer를 사용하는 LSTM을 사용했다. 세 번쨰로는 input sequence의 순서를 뒤집어서 사용했다. 예를 들면 문장 a, b, c를 d, e, f로 번역하는 대신 순서를 바꿔 c, b, a 를 LSTM을 통해 d, e, f 값이 나오도록 학습시켰다.(a->d, b->e, c->f 가 정확한 번역) 이러한 간단한 data transformation이 LSTM의 성능을 획기적으로 올려준다는 것을 확인 했다.

Experiments

WMT’14 English to French 기계번역 테스크에 이 모델을 적용시켰다. 그리고 다른 SMT 시스템을 참고하지 않고 직접 이 모델을 통해 번역했다.

데이터에 대해서 자세한 사항은 총 12M개의 sentence 중 일부를 학습시켰는데 여기에는 348M개의 프랑스어 단어와 304M개의 영어 단어가 포함되어있다. 그리고 두 언어에 대해서 각각 일정한 vocabulary를 사용했는데, 여기에는 160,000개의 가장 많이 사용되는 단어가 포함되어 있다. 그리고 vocabulary에 포함되지 않은 단어는 “UNK”라는 토큰으로 대체했다.

실험의 핵심은 크고 깊은 LSTM 모델을 많은 문장 쌍으로 학습시키는 것이다. 학습은 주어진 문장 $S$ 에 대한 정확히 번역된 문장 $T$ 의 log-확률값을 최대화 하는 것이다. 따라서 objective 함수는 다음과 같다.

$1/\vert S\vert\sum_{(T,S)\in S}\log p(T\vert S)$

여기서 $S$ 가 training set이 된다. 학습이 끝난 후에는 주어진 문장에 대해서 가장 높은 확률을 같은 문장 $T$ 를 찾는다.

$\hat{T}=\arg\max_T p(T\vert S)$

실제 예측 과정에서는 간단한 left-to-right beam search decoder를 사용했다. 즉 어떤 특정 $B$개의 문장을 정하고 각 timestep마다 다른 문장들을 추가한 후 위의 log-확률이 높은 B개를 제외하고 나머지는 모두 버린다. 그리고 “" 토큰이 나오면 문장에 이 토큰을 더해 완성된 문장을 만든다. Decoder의 경우 근사시키는 방법인 반면 이 방법은 구현하기 매우 간단하다. beam size를 1로 했을 때도 매우 잘 동작했다.

Reversing the Source Sentence

앞서 말했듯이 LSTM에서 source sentence를 거꾸로 사용했을 때 더욱 좋은 결과를 만들어 냈다. 이러한 방법을 통해 perplexity는 5.8에서 4.7까지 떨어졌고, BLEU score는 25.9에서 30.6까지 올랐다.

이러한 현상에 대해서 정확한 이유는 아직 모르지만, input sentence를 뒤집음으로써 각 대응되는 단어끼리의 평균 길이는 변하지 않고 처음의 단어에 대해 대응되는 단어와 거리가 가까워지기 때문에 조금 더 효율이 올라갔을거라는 추측을한다.

Training detalis

학습과정에서 사용한 방법들의 자세한 설명은 다음과 같다.

4개의 layer
1000개의 cell
단어의 경우 1000 dimension으로 embedding
160,000개의 input vocabulary
80,000개의 output vocabulary
모든 파라미터는 (-0.08, 0.08)사이의 uniform distribution이루도록 초기화
SGD 사용, learning rate = 0.7, 5에폭 후에는 0.5에폭마다 learning rate를 절반으로 줄임. 총 7.5에폭으로 학습
128 sequence 크기의 배치 사용
Vanishing gradient는 발생하지 않았지만, exploding gradient의 발생 떄문에 gradient의 norm 값에 대해 constraint를 줌. 즉 매 배치에 대해서 평균 gradient의 L2 norm값이 5를 넘어가면 5값을 줌.
대부분의 문장은 20~30정도의 길이로 짧았지만 몇몇의 경우 100이상의 길이인 경우도 있었다. 따라서 128의 mini batch에는 주로 짧은 문장이 대부분이였고 긴문장 몇개가 포함되었다. 따라서 미니배치로 학습시 길이가 너무 달라 학습이 잘되지 않는 문제를 위해 미니배치안에서 길이를 고정시켰다.

Result

결과는 다음과 같다.

그리고 이 모델에서 중간의 input에서 output으로 가는 hidden state의 값인 고정된 벡터를 PCA를 통해 2차원 좌표상에 나타낸 결과는 다음과 같다.

결과를 보면, 문장 순서에 따라 값이 매우 달라지는 것을 볼 수 있고, 능/수동 은 크게 상관없는 것을 확인 할 수 있다.

CS20(TensorFlow) Lecture Note (1),(2): Overview & TensorFlow Operation

2018-08-13T04:47:35+00:00

CS20: TensorFlow for Deep Learning Research

Post list

1. Introduction to TensofFlow

텐서플로우에 대한 소개는 텐서플로우 웹사이트에서 소개한 말을 인용한다.

TensorFlow is an open source software library for numerical computation using data flow graphs

소개에 대한 부분은 자세히 쓰지 않는다. 텐서플로우의 장점 및 자세한 내용은 텐서플로우 홈페이지를 참고하자.

2. TensorFlow Ops

TensorBoard

텐서플로우의 사용 방법 이전에 우선 텐서플로우를 사용하면서 좀 더 직관적인 이해와 시각화를 위한 소프트웨어인 텐서보드를 먼저 소개한다.

텐서보드는 텐서플로 설치시 포함되어있는 Graph visualization 소프트웨어로 Google의 TensorBoard에 대한 설명을 인용한다.

“The computations you’ll use TensorFlow for - like training a massive deep neural network - can be complex and confusing. To make it easier to understand, debug, and optimize TensorFlow programs, we’ve included a suite of visualization tools called TensorBoard”

텐서플로우로 실행시킨 내역에 대해서 텐서보드로 확인 할 수 있다. 예를 들어 아래의 텐서플로우 코드에 대해서 텐서보드로 확인한다고 하자.

import tensorflow as tf
a = tf.constant(2)
b = tf.constant(3)
x = tf.add(a, b)
with tf.Session() as sess:
      print(sess.run(x))

텐서보드로 실행시키기 위해서는 계산되는 값에 대해 log file을 만들어 줭야 한다. 따라서 아래의 명령어를 입력해야 한다.

writer = tf.summary.FileWriter([logdir], [graph])

logdir은 log file이 저장될 경로를 뜻하고, graph는 우리가 동작시키는 프로그램의 하나의 graph를 뜻한다.

로그파일을 저장했다면 명령 프롬프트에서 다음과 같이 입력하면 된다.

$ python [my_program.py]
$ tensorboard --logdir="logdir" --port 6006

이후 웹 브라우저에서 http://localhost:6006으로 들어가면 TensorBoard를 사용할 수 있다.

그리고 텐서보드를 사용할 때 로그파일을 저장하는데, log파일이 쌓여서 겹칠 경우에는 가장 최신의 파일을 인식한다. 그리고 경고가 뜨는데 이 경고를 없에기 위해서는 쌓여있는 log파일을 정리해줘야 한다.

Constant

constant를 만드는 가장 기본적인 방법은 다음과 같다.

tf.constant(value, dtype=None, shape=None, name='Const',verify_shape=Flase)

그 외에 다양한 종류의 constant를 만드는 방법은 다음과 같다.

tf.zeros(shape, dtype=tf.float32, name=None)
tf.zeros_like(input_tensor, dtype=None, name=None, optimize=True)
tf.ones(shape, dtype=tf.float32, name=None)
tf.ones_like(input_tensor, dtype=None, name=None, optimize=True)
tf.fill(dims, value, name=None)
tf.lin_space(start, stop, num, name=None)
tf.range([start], limit=None, delta=1, dtype=None, name='range')

여기서 주의해야 할 점은 아래의 tf.lin_space()와 tf.range()함수는 iterable하지 않기 때문에 for문에서 사용할 수 없다.

각 함수를 사용해서 직접 만드는 예시는 다음과 같다.

tf.zeros([2, 3], tf.int32) ==> [[0, 0, 0], [0, 0, 0]]
tf.zeros_like(input_tensor) ==> [[0, 0], [0, 0], [0, 0]]
tf.ones([2, 3], tf.int32) ==> [[1, 1, 1], [1, 1, 1]]
tf.ones_like(input_tensor) ==> [[1, 1], [1, 1], [1, 1]]
tf.fill([2, 3], 8) ==> [[8, 8, 8], [8, 8, 8]]
tf.lin_space(10.0, 13.0, 4, name="linspace") ==> [10.0 11.0 12.0 13.0]
# 'start' is 3, 'limit' is 18, 'delta' is 3
tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
# 'limit' is 5
tf.range(limit) ==> [0, 1, 2, 3, 4]

위의 방법외에도 random한 값을 가지는 constant를 지정해줄 수 있는데 아래와 같은 다양한 함수를 통해 만들 수 있다.

tf.random_normal
tf.truncated_normal
tf.random_uniform
tf.random_shuffle
tf.random_crop
tf.multinomial
tf.random_gamma
tf.set_random_seed

이 함수들의 자세한 내용은 링크를 참고하자

Math Operation

텐서플로우는 많은 수학 연산을 제공하는데 전체 리스트는 링크를 참고하자.

Division operation

텐서플로우에는 다양한 나눗셈 연산들이 있다. tf.division은 일반적인 파이썬의 연산을 생각하면 된다. 그리고 tf.div는 텐서플로우 스타일의 나눗셈 연산으로 사용된다. 전체 나눗셈에 대한 자세한 내용은 documentation을 참고하자. 아래는 나눗셈을 사용하는 예시이다.

a = tf.constant([2, 2], name='a')
b = tf.constant([[0, 1], [2, 3]], name='b')
with tf.Session() as sess:
	print(sess.run(tf.div(b, a)))             ⇒ [[0 0] [1 1]]
	print(sess.run(tf.divide(b, a)))          ⇒ [[0. 0.5] [1. 1.5]]
	print(sess.run(tf.truediv(b, a)))         ⇒ [[0. 0.5] [1. 1.5]]
	print(sess.run(tf.floordiv(b, a)))        ⇒ [[0 0] [1 1]]
	print(sess.run(tf.realdiv(b, a)))         ⇒ # Error: only works for real values
	print(sess.run(tf.truncatediv(b, a)))     ⇒ [[0 0] [1 1]]
	print(sess.run(tf.floor_div(b, a)))       ⇒ [[0 0] [1 1]]

tf.add_n

덧셈 연산을 한다. tf.add_n([a,b,b])는 a+b+b와 같다.

Dot product & matmul

tf.matmul과 tf.tensordot을 구분해서 사용해야 한다. 전자는 rank가 2이상인 matrix에서 사용하는 것이다. 아래의 예시를 보자.

a = tf.constant([10, 20], name='a')
b = tf.constant([2, 3], name='b')
with tf.Session() as sess:
	print(sess.run(tf.multiply(a, b)))           ⇒ [20 60] # element-wise multiplication
	print(sess.run(tf.tensordot(a, b, 1)))       ⇒ 80

Data Type

Python Native Type

파이썬의 기본 데이터 타입의 경우에는 텐서플로우에서 다음과 같이 취급 된다.

Data	example	in Tensor
Single value	Bool,String,Numeric	0-d tensor(scalar)
List of value	[‘a’,’b’,’c’], [2,3],[True,False]	1-d tensor(vector)
List of list	[[1,2,], [2,3]]	2-d tensor(matrix)

파이썬 데이터 타입을 사용하면 예를들어 아래와 같이 적용된다.

t_0 = 19 # Treated as a 0-d tensor, or "scalar"
tf.zeros_like(t_0)                   # ==> 0

t_1 = [b"apple", b"peach", b"grape"] # treated as a 1-d tensor, or "vector"
tf.zeros_like(t_1)             

t_2 = [[True, False, False],
       [False, False, True],
       [False, True, False]]         # treated as a 2-d tensor, or "matrix"

tf.zeros_like(t_2)                   # ==> 3x3 tensor, all elements are False

TensorFlow Native Data

텐서플로우는 많은 데이터 타입을 가지고 있다. 전체 리스트는 다음과 같다.

tf.float16: 16-bit half-precision floating-point.
tf.float32: 32-bit single-precision floating-point.
tf.float64: 64-bit double-precision floating-point.
tf.bfloat16: 16-bit truncated floating-point.
tf.complex64: 64-bit single-precision complex.
tf.complex128: 128-bit double-precision complex.
tf.int8: 8-bit signed integer.
tf.uint8: 8-bit unsigned integer.
tf.uint16: 16-bit unsigned integer.
tf.uint32: 32-bit unsigned integer.
tf.uint64: 64-bit unsigned integer.
tf.int16: 16-bit signed integer.
tf.int32: 32-bit signed integer.
tf.int64: 64-bit signed integer.
tf.bool: Boolean.
tf.string: String.
tf.qint8: Quantized 8-bit signed integer.
tf.quint8: Quantized 8-bit unsigned integer.
tf.qint16: Quantized 16-bit signed integer.
tf.quint16: Quantized 16-bit unsigned integer.
tf.qint32: Quantized 32-bit signed integer.
tf.resource: Handle to a mutable resource.
tf.variant: Values of arbitrary types.

텐서플로우의 데이터 타입을 보면 Numpy의 데이터 타입과 비슷하게 생겼다는 것을 알 수 있다. 실제로도 두 데이터 타입은 같은 데이터 타입이다. 텐서플로우의 것이 넘파이의 데이터 타입을 기반으로 만들어졌기 때문이다. 따라서 tf.int32 == np.int32 와 같이 사용하면 True의 반환한다.

그리고 넘파이 데이터로 텐서플로우 데이터 생성시 run하기 전까지는 텐서플로우 데이터로 나오나 run이후에는 넘파이 데이터로 나온다.

sess = tf.Session()
a = tf.zeros([2, 3], np.int32)
print(type(a))  			# ⇒ <class 'tensorflow.python.framework.ops.Tensor'>
a = sess.run(a)
print(type(a))  			# ⇒ <class 'numpy.ndarray'>

Variables

Constant와 variable의 차이에 대해서 먼저 얘기해보자.

constant는 constant이다. 즉 불변하다는 것이다. 학습과정에서 우리는 weight와 bias를 update해줘야 한다.
constant 값은 graph에 저장된다. 그리고 graph가 로드될 때 마다 계속해서 복제된다. 그러나 variable은 각각 저장되어서 복제되지 않고 parameter서버에서 동시에 사용된다.

2번의 내용이 매우 중요하다. constant는 graph definition에 저장되는데 constant 자체가 매우 크면 계속해서 graph를 호출할 때 마다 복제되어서 시스템이 느려진다. 여기서 말하는 graph의 정의를 호출하는 방법은 다음과 같다.

import tensorflow as tf

my_const = tf.constant([1.0, 2.0], name="my_const")
print(tf.get_default_graph().as_graph_def())

결과는 다음과 같다.

node {
  name: "my_const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 2
          }
        }
        tensor_content: "\000\000\200?\000\000\000@"
      }
    }
  }
}
versions {
  producer: 24
}

Creating variables

변수를 선언하기 위해서는 우선 tf.Variable객체의 인스턴스를 만들어야한다.

tf.constant의 c는 소문자이고 tf.Variable의 V는 대문자이다. 그 이유는 constant는 연산이고 Variable은 연산을 포함하는 객체이기 때문이다.

변수를 만드는 고전적인 방법은 tf.Variable(<initial-value>, name=<optional-name>)를 사용하는 것이다. 예시를 보자.

s = tf.Variable(2, name="scalar")
m = tf.Variable([[0, 1], [2, 3]], name="matrix")
W = tf.Variable(tf.zeros([784,10]))

하지만 이러한 고전적인 방법보다는 tf.get_variable을 사용하는 것을 추천한다. 이 방법을 통하면 변수들을 공유하는 것이 매우 쉬워진다. 사용하는 방법은 다음과 같다.

tf.get_variable(
    name,
    shape=None,
    dtype=None,
    initializer=None,
    regularizer=None,
    trainable=True,
    collections=None,
    caching_device=None,
    partitioner=None,
    validate_shape=True,
    use_resource=None,
    custom_getter=None,
    constraint=None
)

직접 tf.get_variable 사용해서 변수를 생성해보자.

s = tf.get_variable("scalar", initializer=tf.constant(2))
m = tf.get_variable("matrix", initializer=tf.constant([[0, 1], [2, 3]]))
W = tf.get_variable("big_matrix", shape=(784, 10), initializer=tf.zeros_initializer())

Initialize variables

변수를 선언만하고 값을 할당하지 않으면 FailedPreconditionError가 발생하면서 사용할 수 없다. 따라서 우리는 변수를 초기화 해야 하는데, 초기화에는 다양한 방법들이 있다. 우선은 방법들을 알아보기 전에 초기화되지 않은 변수들의 리스트를 확인하는 방법에 대해서 먼저 알아보자.

print(session.run(tf.report_uninitialized_variables()))

그리고 모든 변수를 한번에 초기화하는 방법은 다음과 같다.

with tf.Session() as sess:
	sess.run(tf.global_variables_initializer())

부분적으로 초기화 하거나 하나씩 초기화하는 방법은 다음과 같다.

#initialize subset of variables
with tf.Session() as sess:
	sess.run(tf.variables_initializer([a, b]))
#initialize each variables
with tf.Session() as sess:
  	sess.run(W.initializer)

Assign values to variables

변수에 값을 할당하는 방법은 tf.Varibale.assign()를 사용하는 것이다.

W = tf.Variable(10)
W.assign(100)
with tf.Session() as sess:
	sess.run(W.initializer)
	print(W.eval()) # >> 10

하지만 위와 같이 실행을 하면 W에 100이 할당되지 않은 것을 확인할 수 있다. 왜 그럴까? 이유는 assign을 선언만 해놓고 실제 실행을 하지 않았기 떄문이다.(assign도 하나의 연산이기 떄문에 run해줘야 적용된다.)

즉 아래와 같이 assign을 run을 해야 한다.

W = tf.Variable(10)

assign_op = W.assign(100)
with tf.Session() as sess:
	sess.run(assign_op)
	print(W.eval()) # >> 100

그리고 변수를 초기화할 떄 assign을 사용해서 초기화 할 수도 있다.

# in the source code
self._initializer_op = state_ops.assign(self._variable, self._initial_value,validate_shape=validate_shape).op

assign_add, assign_sub등 여러 할당 함수들이 있다.

W = tf.Variable(10)

with tf.Session() as sess:
	sess.run(W.initializer)
	print(sess.run(W.assign_add(10))) # >> 20
	print(sess.run(W.assign_sub(2)))  # >> 18

Interactive Session

Interacitve session을 사용하면 별다른 session을 호출할 필요없이 바로 run, eval을 할 수 있다. 간단한 방법이지만 만약 여러 session을 다루기에는 어려움이 있다.

sess = tf.InteractiveSession()
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a * b
print(c.eval()) # we can use 'c.eval()' without explicitly stating a session
sess.close()

Importing Data

이제 텐서플로우 사용에서 가장 중요한 방법인 data를 불러오는 방법이다. 먼저 기존의 방식에 대해서 설명한다.

기존의 방식은 placeholders 와 feed_dict를 사용하는 방식이다.

paceholders란 데이터를 담아둘 곳이라고 생각하면 된다. 그리고 feed_dict를 통해 값을 할당하면 된다. 우선 placeholder를 정의하는 방법은 다음과 같다.

tf.placeholder(dtype, shape=None, name=None)

옵션을 보면 dtype은 데이터 타입을 뜻하고 name은 사용자가 지정할 이름을 뜻한다. 그리고 shape는 담을 데이터의 형태를 뜻하는데 만약 지정하지 않으면 어떤 데이터이든지 넣을 수 있다는 장점이 있지만 디버그과정에서는 문제가 되는 부분을 찾기가 매우 힘들어 진다. 따라서 웬만하면 shape를 지정하도록 하자.

이제 placeholder를 정의하고 feed_dict를 통해 값을 할당하는 방법에 대해 알아보자.

a = tf.placeholder(tf.float32, shape=[3]) # a is placeholder for a vector of 3 elements
b = tf.constant([5, 5, 5], tf.float32)
c = a + b # use the placeholder as you would any tensor

with tf.Session() as sess:
	# compute the value of c given the value of a is [1, 2, 3]
	print(sess.run(c, {a: [1, 2, 3]})) 		# [6. 7. 8.]

위와 같이 사용하면 된다. feed_dict는 iterative하게 사용가능하다.

with tf.Session() as sess:
	for a_value in list_of_a_values:
		print(sess.run(c, {a: a_value}))

그리고 feed_dict는 placeholder에만 사용되는 것이 아니고 일반 연산에서도 사용 가능하다.

a = tf.add(2, 5)
b = tf.multiply(a, 3)

with tf.Session() as sess:
	print(sess.run(b)) 						# >> 21
	# compute the value of b given the value of a is 15
	print(sess.run(b, feed_dict={a: 15})) 			# >> 45

위의 place_holder와 feed_dict는 데이터를 다루는 고전적인 방법이라고 배웠다. 그렇다면 최신의 방법은 무었일까 바로 tf.data를 사용하는 것이다. 이 방법에 대해서는 다음 강의에서 알아보도록 한다.

Lazy Loading

마지막으로 텐서플로우를 사용하면서 발생할 수 있는 문제에 대해서 소개한다. 우선 아래의 두 예시를 보자.

x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')
z = tf.add(x, y)

with tf.Session() as sess:
	sess.run(tf.global_variables_initializer())
	writer = tf.summary.FileWriter('graphs/normal_loading', sess.graph)
	for _ in range(10):
		sess.run(z)
	writer.close()

x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')

with tf.Session() as sess:
	sess.run(tf.global_variables_initializer())
	writer = tf.summary.FileWriter('graphs/lazy_loading', sess.graph)
	for _ in range(10):
		sess.run(tf.add(x, y))
	print(tf.get_default_graph().as_graph_def())
	writer.close()

예시를 보면 두 코드다 같이 반복적으로 add연산을 수행하고 있다. 하지만 실행해보면 아래의 코드가 속도가 더 느리다. 만약 반복횟수가 더 커지면 커질수록 느려질 것이다. 왜그럴까?

아래의 코드는 ‘add’ 노드를 연산 수행할 때마다 계속해서 정의하고 수행한다. 그에 반해 첫번째 코드는 연산을 먼저 정의한 후 정의한 연산을 반복 사용만하는 것이다. 따라서 아래의 코드에 비해 속도가 빠른것이다.

위와 같이 정의자체를 반복하도록하면 ‘add’ 노드 자체가 여러개 생겨서 속도가 느려질 것이다. 따라서 코딩을 할 때 연산의 경우 정의와 실행을 구분해서 사용하도록 하자.

Seq2seq (1): Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation

2018-08-13T04:47:35+00:00

최근의 기계 번역(Machine) 분야에서 주를 이루고 있는 Neural Machine Translation의 시초를 뽑으라고 하면 Sequence to Sequence 모델을 뽑을 것이다. Google이 발표한 논문인 ‘Sequence to Sequence with Neural Network’를 통해 본격적인 NML분야가 활발해졌다고 볼 수 있다.

따라서 이번 포스트에서는 sequence to sequence 모델에 대해서 알아 보도록 할 것이다. 앞서 말한 구글의 논문 이전에 최초로 sequence to sequence모델을 도입한 논문인 ‘Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation’(paper)에 대해 먼저 알아 본 후 다음 포스트를 통해 google의 ‘Sequence to Sequence with Neural Network’(paper)에 대해 알아보도록 한다.

Sequence to sequence는 가장 많이 사용되는 기계번역 분야 뿐만 아니라 다양한 분야에서 사용된다. sequence를 사용하는 분야라면 어느 테스크에서든 사용할 수 있다. RNN을 기본으로한 모델인 이 모델은 뉴욕대의 조경현교수님께서 만드신 모델이다. 이 논문을 통해 seqeunce to sequence가 세상에 소개된 것 뿐만 아니라 새로운 RNN 구조인 GRU 또한 소개되어서 세상의 많은 관심을 받은 논문이다.

처음 sequence to sequence의 개념이 도입된 이 논문에서는 sequence to sequence라는 이름을 쓰지 않고 encoder-decoder로 표현되었다. 이제 논문을 보며 자세히 알아보도록 하자.

Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation

Introduction

Neural network를 활용해서 Object detection분야와 speech recognition분야에서 많은 성과를 보여줬다. 뿐만 아니라 최근에는 NLP분야에서도 nerual network를 통해 많은 발전을 이뤄왔다. 그리고 기계 번역 분야에서 기존에 활용되던 Statical Machine Translation(SMT)분야에서의 Neural network의 접목을 통해 더 좋은 성능을 보여줬는데 이 논문에서도 SMT의 한 부분으로 Neural network를 사용하는 것을 보여줄 것이다.

앞으로 보여줄 모델을 RNN Encoder-Decoder라 부른다. 이 모델의 구성은 각각 encoder, decoder 역활을 하는 두개의 RNN으로 구성되어 있는데 encoder는 가변 길이의 sequence를 고정길이의 벡터로 만들고 decoder는 이렇게 seuquence를 vector로 표현한 것을 다시 가변 길이의 sequence로 바꿔준다. 이 두개의 네트워크는 주어진 sequence에 대해서 target sequence의 조건부 확률을 최대화 시키면서 학습된다. 그리고 부가적으로 메모리 사용량과 학습을 쉽게해줄 몇가지 정교한 hidden unit에 대해서도 소개할 것이다.

모델의 평가는 English-French 번역 결과에 대한 점수를 통해 평가한다. 이제 모델에 대해서 자세히 알아보자.

RNN Encoder-Decoder

앞서 말했듯이 encode 는 가변길이의 sequence를 고정길이의 벡터 representation으로 만드는 것이고 decode 는 고정길이의 벡터 representation을 다시 가변길이의 sequence로 만드는 것을 뜻한다. 확률적인 관점에서 이 모델은 input 값인 가변길이의 sequence에 대한 decoder에 의해 만들어진 가변길이의 sequence의 조건부 분포를 학습하는 것이다. 즉 아래의 확률 분포를 학습한다.

$p(y_1,..,y_{T'}~\vert~x_1,...,x_T)$

여기서 길이를 뜻하는 $T$ 와 $T'$ 은 다른 길이이다.

Encoder-Decoder의 그림은 다음과 같다.

Encoder는 하나의 RNN이며, input sentence $\mathbf{x}$ 의 각 symbol을 순서대로 읽는다. 각 symbol을 읽을 때, 이 RNN 구조의 각 hidden state는 각 symbol값은 아래의 수식으로 계산된다.

$\mathbf{h}_{<t>}=f(\mathbf{h}_{<t-1>},x_t)$

전체 sequence에 대해 모든 symbol을 마지막 까지 다 읽은 후에는, 마지막 hidden state에서 전체 input sequence를 하나의 벡터 $\mathbf{c}$ 로 요약한다. 여기까지가 encoder에 대한 설명이다.

Decoder는 또 하나의 다른 RNN이다. 여기서는 RNN은 주어진 hidden state 값인 $\mathbf{h}_{<t>}$ 를 활용해서 다음 symbol인 $y_t$ 를 예측하면서 전체 output sequence를 만들어 내면서 학습된다. 여기서는 위의 encoder에서 사용된 일반적인 RNN수식으로 hidden state값을 계산하는 것이 아니라 이전의 output symbol인 $y_{t-1}$ 값도 사용한다. 즉 아래의 수식으로 계산된다.

$\mathbf{h}_{<t>}=f(\mathbf{h}_{<t-1>}, y_{t-1}, \mathbf{c})$

따라서 이 수식은 다음 symbol에 대한 조건부 분포로 나타내면 다음과 같다.

$p(y_t\vert y_{t-1}, y_{t-2},...,y_1,\mathbf{c})=g(\mathbf{h}_{<t>},y_{t-1},\mathbf{c})$

여기서 $f,g$는 활성화 함수이다.(e.g. softmax)

두 개의 부분으로 구성된 이 RNN Encoder-Decoder 는 다음의 조건부 log-확률을 최대화하면서 학습된다.

$\max_\theta\frac{1}{N}\sum^N_{n=1}\log p_\theta(\mathbf{y}_n\vert\mathbf{x}_n)$

$\theta$ 는 모델의 파라미터를 뜻하고 $(\mathbf{x}_k, \mathbf{y}_k)$ 는 학습 데이터의 input sequence, output sequence 쌍이다.

학습의 경우는 gradient-based 알고리즘을 사용해서 모델의 파라미터를 학습시켰다.

일단, RNN Encoder-Decoder가 학습되면 모델은 두개의 용도로 사용된다. 하나는 주어진 input sequence에 대해서 target sequence를 만드는 용도로 사용되었고, 또 다른 하나의 용도는 주어진 두개의 sequence 쌍(input sequence, output sequence)에 대해서 위에 주어진 확률 값을 사용해서 점수를 매기는 용도로 사용되었다.

Hidden Unit that Adaptively Remembers and Forgets

위의 모델 architecture 뿐만 아니라 이 구조를 위해 새로운 형태의 hidden unit을 사용했다. 먼저 general한 RNN 수식을 보자.

$\mathbf{h}_{<t>}=f(\mathbf{h}_{<t-1>},x_t)$

여기서 함수 $f$는 단순히 일반적인 activation 함수를 뜻할 수도 있고 LSTM의 수식으로 activate되는 것을 뜻할 수도 있다. 새로운 형태의 hidden unit이란 새롭게 정의한 이 함수를 뜻하는데 LSTM을 motive로 해서 만들어 졌으나, 훨신 계산이 쉽고 구현이 쉬운형태이다.

새롭게 정의한 hidden unit을 그림으로 표현하면 다음과 같다.

이제 이 hidden unit에서 어떻게 activate되는지 알아보자. 먼저 reset gate인 $r_j$ 는 다음과 같이 계산된다.

$r_j=\sigma\big([\mathbf{W}_r\mathbf{x}]_j+[\mathbf{U}_r\mathbf{h}_{<t-1>}]_j \big),$

여기서 $\sigma$ 는 logistic sigmoid 함수이고 $[.]_j$ 는 벡터의 $j$ 번째 원소를 뜻한다. 그리고 $\mathbf{x}$ 와 $\mathbf{h}_{t-1}$ 은 각각 input과 이전 hidden state를 뜻한다. 마지막으로 $\mathbf{W}_r$ 과 $\mathbf{U}_r$ 은 학습해야 할 weight matrix이다.

그리고 또 하나의 gate인 update gate $z_j$ 는 다음과 같이 계산된다.

$z_j=\sigma\big([\mathbf{W}_z\mathbf{x}]_j+[\mathbf{U}_z\mathbf{h}_{<t-1>}]_j \big),$

이제 두 gate의 값을 사용해서 hidden unit 값을 계산한다.

$\begin{matrix} h_j^{<t>}=z_jh_j^{<t-1>}+(1-z_j)\tilde{h}_j^{<t>}\\ \\ \tilde{h}_j^{<t>}=\phi\big([\mathbf{W}\mathbf{x}]_j+[\mathbf{U}(\mathbf{r}\odot\mathbf{h}_{<t-1>})]_ j \big) \end{matrix}$

이 공식에 따르면 reset gate가 0에 가까워지면 hidden state는 이전 hidden state값을 무시하게 된다. 그리고 현재 input값으로만 reset되게 된다. 따라서 효과적으로 hidden state의 다음 앞으로의 state와 관계가 없는 정보는 제거(drop)할 수 있게 되기 때문에 더욱 압축적인 정보를 갖게 된다.

반면에 update gate는 얼마나 많은 정보를 이전 hidden state로 부터 가지고 올것인지를 결정하는데, 이것은 실제로 LSTM의 memory cell과 유사하게 동작한다. 따라서 오래된 정보를 RNN에게 전달할 수 있게 된다. 또한 adaptive variant of leaky-integration unit을 고려한다.

각 hidden unit은 개별의 reset과 update gate를 가지는데, 각 hidden unit은 다른 시간 scale에 대한 의존성을 통해 학습한다.(특성에 따라 long-term의 값을 사용하거나, short-term의 값을 사용한다)

Statistical Machine Translation

기존의 흔히 사용되던 statistical machine translation 시스템의 목표는 주어진 문장 $\mathbf{e}$ 에 대해translation function인 $f$ 를 찾는 것이다. 즉 아래의 식을 최대화 하기 위한 것이다.

$p(\mathbf{f}\vert\mathbf{e})\propto p(\mathbf{e}\vert\mathbf{f})p(\mathbf{f})$

하지만 실제로는 대부분의 SMT 시스템은 아래의 log식을 모델링한다.

$\log p(\mathbf{f}\vert\mathbf{e})=\sum^N_{n=1}w_n f_n(\mathbf{f},\mathbf{e})+\log Z(\mathbf{e})$

여기서 $f_n$ 과 $w_n$ 은 각각 n번째 feature와 weight이다. 그리고 $Z(\mathbf{e})$ 는 일반화 상수이다. 경우에 따라 여기서의 weight는 BLEU(bilingual evalutation understudy)값을 최대화 하기 위해 학습된다.

phrase 기반의 SMT는 어절 단위의 통계적 기계 번역으로 각 어절에 대해서 그에 대응하는 문장에 대한 확률로 나눠서 계산한다.

Experiments

실험은 WMT’14의 English/French 번역 task를 통해 진행되었다. 이 bilingual한 말뭉치는 Europarl(61M words), news commentary(5.5M words), UN(421M words)과 90M, 780M개의 crawled한 copora를 포함한다.

그리고 French language model을 학습하기 위대 대략 712M 개의 단어를 학습했다.

일반적으로 statistical한 모델을 학습시킬 때 여러 데이터들을 concat하는 것이 항상 최적의 성능을 보장하지 않을 뿐더러 큰 모델일수록 다루기 어렵기 떄문에 여기서는 data selection 방법(Moore and Lewis,2010)을 적용했다. 이러한 방법을 사용해서 Language modeling을 위해 418M개의 단어를 뽑았으며, 학습을 위해 348M개의 단어를 뽑았다.

데이터 셀렉션과 weight tuning을 위해 nestest2012 와 2013 사용했고 테스트를 위해서 nestest 22014를 사용했다. 각각의 set은 7만개 이상의 단어로 구성되어있다.

RNN Encoder-Decoder를 포함하는 이 네트워크를 학습하기 위해 source, target vocabulary의 크기를 각각 가장 많이 나오는 English, French 둘다 15,000개의 단어만 포함하도록 제한했다. 이 15,000개의 단어는 전체 단어의 93%에 달한다. 그리고 모든 out-of-vocabulary 단어는 ([UNK]) 토큰으로 바꾸었다.

실험 결과에 대해 baseline phrase-based SMT 시스템은 기본값의 Moses를 사용해서 만들었다. 이 시스템의 BLEU 스코어느 30.64, 33.3이다.

RNN Encoder-Decoder in experiment

실험에 사용된 RNN Encoder-Decoder의 구조는 다음과 같다.

1000 hidden unit(GRU 사용)
input symbol에서 hidden unit으로 갈 떄 사용되는 input matrix는 2 lower-rank approxiamtion한 matrix 사용, output matrix로 같은 방식 사용
rank 100 Matrix 사용
hidden unit 계산 시 $\tilde{h}$ 계산할 때 활성화 함수로 tanh사용
Decoder에서 hidden state 값으로 output 계산과정에서는 deep neural network 구조 사용(single intermediate layer, 500 maxout units,pooling 2 input)
모든 파라미터는 (0, 0.01)의 가우시안 분포로 초기화
파라미터 업데이트에는 SGD, Adadelta 사용(hyperparameter는 $\epsilon=10^{-6}, \rho=0.95$ 사용)
매 업데이트 마다 64개의 임의 추출된 phrase pair사용

실험에서는 target language를 학습하기 위한 전통적인 neural network 인 CSLM도 추가해서 실험했다. 그리고 추가적으로 word penalty 방식도 추가했다. 따라서 실험을 위한 모든 조합은 다음과 같다.

Baseline
Baseline + RNN
Baseline + CSLM + RNN
Baseline + CSLM + RNN + Word Penalty

실험에 대한 결과는 다음과 같다.

결과를 보면 우선 encoder-decoder방식을 사용하면서 성능이 올라갔으며, CSLM과 같이 사용할 때 더 성능이 올라갔다. 하지만 Word penalty를 적용시켰을 때 test에서 성능이 약간 떨어졌다.

그리고 BLEU 스코어 뿐만 아니라 Qulitative한 분석을 통해서 이 모델이 의미적, 그리고 문법적으로도 잘 분석한다는 것을 확인 할 수 있다.

Chapter 2: Function Approximation as Supervised Learning

2018-08-10T04:47:35+00:00

Chapter 2 Function Approximation as Supervised Learning

이 내용은 Newyork University의 조경현교수님의 DS-GA 3001강의 lecture note중 Neural Laguage Models단원을 정리한 내용입니다.

이번 챕터에서는 인공 신경망을 통해 Natural Language를 함수로 근사시킬 것이다. 이러한 과정은 기본적인 신경망을 공부하는데 도움이 될 것이며, 다음 챕터부터의 공부에 용이하게 할 것이다.

2.1 Function Approximation: Parametrix Approache

2.1.1 Expected Cost Function

가장 먼저 데이터 분포를 $p_{\text{data}}$ 로 정의한다. 각 데이터는 input 벡터인 $\mathbf{x}\in\mathbb{I}^d$ 와 output 벡터인 $\mathbf{y}\in\mathbb{O}^d$ 로 정의한다. $\mathbb{I,O}$ 는 input과 output으로 가능한 실수 값의 집합이다.

이제 우리의 목표는 $\mathbf{x}$ 와 $\mathbf{y}$ 사이의 관계를 찾는 것이다. 정확히는 두 집합사이의 함수 $f:\mathbb{R}^d\rightarrow\mathbb{O}^k$ 를 찾는 것이다. 최대한 정확한 $f$ 를 찾기 위해 함수를 parametric function을 고려한다. 여기서 파라미터는 $\theta$ 라 칭한다.

이제 우리가 근사한 함수가 얼마나 정확히 input에서 output으로 가기위해 확인하기 위해 우리가 예측한 값에 대해 정의한다.

$\hat{\mathbf{y}}=f_{\theta}(\mathbf{x})$

이제 우리가 정의한 함수의 정확도는 위의 값과 output과의 차이( $D(\hat{\mathbf{y}},\mathbf{y})$ )를 비교하면 될것이다. 그리고 최종적으로 해야 할 것은 이 차이를 최소화하는 파라미터 $\theta$ 를 찾으면 된다. 하지만 input과 output은 여러 쌍이 존재하는데 정확히 이 모든 쌍에 대해서 이 차이를 최소화하는 파라미터는 존재하기 어렵다. 따라서 전체 쌍에 대해서 차이의 총합을 최소화 하는 방향으로 가야한다. 이를 수식으로 표현하면 다음과 같다.

$\arg\min_{\theta}\int_{\mathbf{x}}\int_{\mathbf{y}}p_{\text{data}}(\mathbf{x},\mathbf{y})D(\hat{\mathbf{y}},\mathbf{y})d\mathbf{x}d\mathbf{y}$

만약 각 데이터들이 discrete하다면 적분 대신 $\sum$ 을 이용하면 된다. 이제 우리는 최소화 해야 하는 이 값을 Cost Function이라 부를 것이다. 그리고 이 값을 계산하는 것은 distance의 평균(기대값)을 계산하는 것과 같다.

$\begin{align*} C(\theta)&=\int_{\mathbf{x}}\int_{\mathbf{y}}p_{\text{data}}(\mathbf{x},\mathbf{y})D(\hat{\mathbf{y}},\mathbf{y})d\mathbf{x}d\mathbf{y} &=\mathbb{E}_{\mathbf{x},\mathbf{y}\~p_{\text{data}}}[D(\hat{\mathbf{y}},\mathbf{y})] \end{align*}$

이 값을 cost 말고 또 loss 혹은 risk 라고도 부른다.

아쉽게도 이 값을 정확하게 계산하는 것은 불가능하다. 애초에 data의 정확한 distribution을 알지 못하고 안다고 해도 정확히 cost를 계산하는 것은 과한 가정을 필요로한다.

2.1.2 Empirical Cost Function

우리가 정확한 data의 분포를 모른다고 하더라도 일정 크기의 data는 우리에게 주어진다. 따라서 sampleling의 가정을 통해 정확한 cost를 근사하는 값을 구할 수 있다.

$C(\theta)\approx\tilde{C}(\theta)=\frac{1}{N}\sum^N_{n=1}D(\hat{\mathbf{y}^n},\mathbf{y}^n)$

이 값을 empirical cost function이라 부른다. 이 값은 계산이 쉽기 때문에 이 값을 사용할 것이다. 하지만 후에 우리의 최종 목표는 정확한 expected Cost를 계산하는 것이다.

2.2 Learning as Optimization

앞서 설명한 Cost값을 가장 최소로하는 파라미터들을 찾아가는 과정을 학습한다 라고 표현한다. 기계에서 학습 데이터를 통해 최적의 함수를 찾도록 하는 것이다. 그리고 이 학습하는 과정을 최적화(optimization)이라고도 한다.

2.2.1 Gradient-based Local Iterative Optimization

최적화 알고리즘은 다양하다. 때로는 closed한 형태의 최적화 파라미터를 찾을 수 있지만 보통의 경우에는 반복적으로 최적화 알고리즘을 수행하면서 최적의 파라미터 값을 찾아가야 한다.

여기서 말하는 반복적 최적화 알고리즘이란 조금씩 파라미터들을 수정하면서 최적의 Cost function, 즉 cost function의 최소값으로 수렴하는 것을 의미한다. 대부분의 파라미터 공간은 지역적이라 전체 공간을 측정할 필요가 없다.

가장 간단한 지역적 반복 최적화 알고리즘 중 하나는 경사하강법(Gradient Discent, GD) 알고리즘이다. 이름에서 나와있듯이 이 알고리즘은 Cost 함수의 미분값(gradient)에 의해 수행된다.

Cost 함수의 미분값인 $\nabla\tilde{C}$ 는 현재 파라미터 값에 대해서 값을 올리는 방향에 대한 벡터값을 갖는다. 따라서 이 벡터값의 반대방향으로 파라미터를 이동시키면 Cost함수가 적어지는 방향으로 이동한다. 아래 그림은 이러한 과정을 나타낸다.

이 알고리즘에서 중요한 점은 우리가 찾은 방향에 대해서 얼마나 움직일 것인가 이다. 만약 너무 많이 움직인 다면 우리가 가야하는 최적의 값을 지나칠 수 있고 너무 조금 움직인다면 최적의 값으로 가기까지가 너무 오래걸린다. 여기서 말한 얼마나 움직일것인가를 나타내는 값은 $\eta$ 로 쓰고 학습률(learning rate)라 표현한다. 이 값은 우리가 정해줘야하는 파라미터 값이므로 GD 알고리즘의 hyperparameter이다.

학습률을 고려한 정확한 경사하강법 알고리즘에서 파라미터를 재정의(update)하는 방법을 정의하면 다음과 같다.

$\theta \leftarrow \theta-\eta\nabla\tilde{C}(\theta)$

위의 update는 우리가 정의한 횟수만큼 반복된 후에 그만한다.

2.2.2 Stochastic Gradient Descent

GD알고리즘은 간단하지만 매우 잘 동작한다. 그리고 이 알고리즘은 앞으로 나올 좀 더 향상된 알고리즘들의 기본 개념이 된다. 좀더 향상된 방법들을 배우기 이전에 GD알고리즘에 대해서 좀더 논의해본다. GD알고리즘에는 약간의 문제점이 있다. 바로 $\tilde{C}$ 을 계산하는 것이 매우 많은 연산을 필요로 한다는 것이다. 데티어가 많아질 수록 연산은 더욱 많아지는데, 그 이유는 앞서 본것처럼 Cost를 계산할 때 우리는 모든 data에 대해서 Cost를 계산한 뒤 모든 값들을 평균한 값을 최종 Cost로 사용한다. 따라서 모든 많은 데이터에 대해서 Cost를 모두 계산해야 하는데 이러한 과정을 반복하기에는 연산량이 매우 많다.

이러한 연산량이 많다는 문제점을 해결하기 위한 알고리즘이 Stochastic gradient descent(SGD)이다.

알고리즘을 설명하기에 앞서 설명한 Cost 함수를 정의를 다시 살펴보자.

$C(\theta)\approx\tilde{C}(\theta)=\frac{1}{N}\sum^N_{n=1}D(\hat{\mathbf{y}^n},\mathbf{y}^n)$

위 식을 보면 Cost 함수의 sum이 모든 데이터인 $N$에 대해서 계산된다. SGD 알고리즘에서는 이 값을 모두 계산하는 것이 아니라 $\mu<N$인 $\mu$개의 데이터에 대해서만 Cost를 계산해 평균한다. 따라서 아래의 식으로 다시 정의된다.

$C(\theta)\approx\tilde{C}_{\mu}(\theta)=\frac{1}{\mu}\sum^\mu_{n=1}D(\hat{\mathbf{y}^n},\mathbf{y}^n)$

따라서 전체 데이터에 대해서 계산하는 일반적인 Cost와는 달리 적은 수에 대해서 Cost를 계산하므로 계산량이 매우 줄어들 것이다. 그리고 계산한 cost에 대해서 앞서 말한 파라미터 업데이트 방법으로 업데이트 하면된다.

여기서 $\mu$는 사용자가 직접 지정하면 되고, 극단적으로 1로 지정해도 된다. 놀랍게도 이미 1951년에 이 방법이 최적값에 수렴한다는 것이 증명 되었다.

2.3 When do we stop learning?

이제부터는 우리는 SGD방법을 통해 최적의 함수 $f$ 를 찾아간다고 하자. 즉 데이터를 조금씩 적용시키면서 학습한다. 이때까지 학습하는 과정에서의 몇 가지 문제점들에 대해서 살펴봤다. 또 하나의 중요한 문제점이 있는데, 우리는 expectec cost function 함수를 사용할 수 없다는 점이다. 그 대신 우리는 empirical cost 함수를 사용한다고 해서 expected cost 함수에 근사시킨다고 했었다. 그런데 왜 이러한 점이 문제점일까? 왜냐하면 우리는 우리가 찾은 empirical cost함수의 minimum값이 expected cost function의 minimum값인지 알 수 없다. 아래의 그림을 보면 두 함수의 최소값이 다른 예를 볼 수 있다.

2.3.1 Early Stopping

그렇다면 우리는 어떻게 해야 하는가? 이러한 문제는 여러가지 방법이 있다. 그 중 하나인 반복적 최적화 방법에서 사용되는 early stopping에 대해서 소개한다.

early stopping을 사용하기위해 우선 데이터를 $D_{\text{train}}$ 과 $D_{\text{validate}}$ 두 부분으로 나눈다. 이 두개의 부분 데이터셋을 학습 데이터(training set), 검증 데이터(validation set)이라 부른다. 이제 학습 cost를 다음과 같이 정의한다.

$\tilde{C}(\theta)=C_{\text{train}}(\theta)=\frac{1}{\vert D_{\text{train}}\vert}\sum_{(x,y)\in D_{\text{train}}}D(\hat{y},y)$

그리고 검증 cost는 다음과 같이 정의한다.

$\tilde{C}(\theta)=C_{\text{val}}(\theta)=\frac{1}{\vert D_{\text{val}}\vert}\sum_{(x,y)\in D_{\text{val}}}D(\hat{y},y)$

이렇게 두개의 cost 함수를 정의하면 early stopping을 사용할 준비가 끝났다.

학습 Cost로 SGD를 사용해서 parameter를 업데이트 할 때마다 검증 Cost를 계산한다. 이러한 과정을 계속 반복하다가 검증 Cost가 줄어들지 않을 때 그 때 반복을 멈춘다.

매우 간단한 방법임에도 불구하고 early stopping 은 매우 효율적이다. 이 방법은 사실상 deep learning과 machine learning 분야에서 표준이 되었다.

이러한 방법, 즉 학습과 검증을 구분한 것의 의미는 학습 데이터에 섞인 노이즈에 의한 학습이 제대로 되지 않는 것을 줄이는 것이다.

2.3.2 Model Selection

검증 데이터를 early stopping에서 활용하는 것에 대해서 알아봤다. ealry stopping 뿐만 아니라 Model Selection 에서도 검증 데이터를 활용한다. 그렇다면 Model selection이 무었인지 알아보도록하자.

전체 최적화, 학습 과정은 전체 hypothesis(가정) space에서 최적의 hypothesis을 찾아가는 과정으로 표현할 수 있다. 여기서 말하는 hypothesis가 의미하는 것은 특정한 파라미터와 특정한 형태를 가지는 함수이다. 회귀(regression)의 경우에 hypothesis space에는 n차 다항식 함수가 포함될 것이다.

$f(x)=\sum_{\sum^d_{k=1}i_k=n,i_k\ge0}a_{i_1,i_2,...,i_k}\prod^d_{k'=1}x_{k'}^{i_k}$

신경망의 경우에는 이러한 hypothesis space는 모든 가능한 모델을 포함할 것이다. 그리고 각각의 hypothesis는 레이어의 수, 비선형성의 종류, hidden unit의 개수에서 특정 값을 가질 것이다.

우리가 특정 hypothesis( $M\in H$ )를 사용한다고 하자. 우리는 각각의 hypothesis에 대해서 각각의 Cost를 점수로 줄 수 있다. 그러면 이제 우리의 최종 목표는 전체적으로 최저의 cost값을 갖는 hypothesis를 선택하는 것이다.

이때까지의 최적화 방법은 반복적으로 empirical cost를 계산하는 것이다. 그러나 이러한 방법은 모델이 overfitting 될 수 있다는 문제점이 있다. 따라서 앞서서 early stopping이라는 기법을 소개했었다.

하지만 이러한 방법으로도 최적의 hypothesis를 찾는 것에는 충분하지는 않다. 우리가 최적이라고 생각하는 hypothesis가 최적이 아닐 수도 있다는 문제점이 항상 존재한다.

이러한 문제의 해결책은 간단하다. 하나 이상의 hypothesis를 고려하는 것이다. 예를들어 회귀문제에 대해서 우리는 linear 함수, quadratic 함수, sinusoidal 함수 모두를 hypothesis로 고려할 수 있다. 이제 마지막 남은 질문은 어떻게 이 hypothesis들을 비교하고 선택해야 하는가 이다.

early sotpping에서 했던 것과 비슷하게 우리는 검증 cost를 이용해 hypothesis들을 비교한다. 우리가 고려한 hypothesis들 중에서 가장 적은 검증 cost 값을 가지는 hypothesis를 선택하면 된다.

2.4 Evaluation

우리는 검증 cost를 통해서 최적화를 early stop했다. 이렇게 찾은 값이 최적화를 위한 값임에는 틀림없지만 실제 세계의 데이터 분포에도 완벽히 최적화된 값이라고 하기에는 어려움이 있다. 일단 최적화가 완료되어도 아직 우리는 더많은 검증을 위한 자료들이 필요하다.

따라서 우리는 데이터를 앞전처럼 두 개로 나누는 것이 아니라 이번에는 세 개로 나눈다. 학습 데이터인 $D_{\text{train}}$ , 검증 데이터 $D_{\text{validation}}$ , 그리고 시험(test) 데이터 $D_{\text{test}}$ . 결과적으로 우리는 학습, 검증, 시험의 총 3개의 cost를 가진다. 여기서 추가로 나눈 시험(test) 데이터는 학습, 검증 데이터를 모두 사용해 최적이라고 선택한 모델에 대해서 시험한다. 테스트 데이터에 대해서 가장 중요한 말이 하나있다. “must never look at a test set”, 즉 test 데이터는 최종적으로 test하기 이전에는 절대 건들면 안된다는 뜻이다.

2.5 Linear Regression for Non-Linear Functions

간단한 linear 함수를 생각해보자.

$\hat{\mathbf{y}}=f(\mathbf{x})=\mathbf{W}^T\mathbf{x}$

여기서 $\mathbf{W}\in\mathbf{R}^{d\times l}$ 는 weight matrix로 이 함수의 파라미터가 된다.

이 때 empirical cost 함수는 다음과 같다.

$\tilde{C}(\theta)=\frac{1}{N}\sum^N_{n=1}\frac{1}{2}\Vert\mathbf{y}^n-\mathbf{W}^T\mathbf{x}^n\Vert^2_2$

그리고 이 empirical cost함수의 gradient는 다음과 같다.

$\nabla\tilde{C}(\theta)=-\frac{1}{N}\sum^N_{n=1}(\mathbf{y}^n-\mathbf{W}^T\mathbf{x}^n)^T\mathbf{x}^n$

위 함수들을 통해 우리는 SGD, GD와 반복적 최적화 알고리즘을 적용시킬 수 있다. 이 알고리즘을 통해 최적의 파라미터 $\mathbf{W}$ 를 찾을 수 있고 또 검증 데이터를 사용해서 early stopping을 사용한다면 더 최적화된 파리미터를 찾을 수 있다. 하지만 이런 linear 함수는 우리가 만족기에는 부족하다.

2.5.1 Feature Extraction

왜 우리는 만족하지 못할까?

첫 째로, 일단 모든 데이터에 맞는 함수가 linear라고 확신 할 수 없다. 만약 맞다고 하더라도 정확하게 linaer regression을 하는 것도 쉽지 않다.

두 번째 이유는 주어진 데이터 $\mathbf{x}$ 에 대해서 어떻게 이 값을 input으로 표현하는지에 대해서 확실한 방법이 없다는 것이다. 예를 들어 5년 전에 판매를 시작한 에어컨의 예상 판매 대수를 예측하는 문제를 생각해보자. 이 때 input을 판매를 시작한 때부터의 기간이라고 가정하고 output을 하루당 판매 대수라고 생각하자.

명백하게 우선 input과 output은 선형관계가 아닐 것이다. 계절에 따라 판매량을 등락을 반복할 것이고 따라서 단순히 직선으로는 표현할 수 없다. 그러나 만약에 input을 위와 같이 판매를 시작한 때부터의 기간이 아니라 6월을 기준으로 몇월 차이가 나는지로 한다고 하자. 예를 들면 8월이면 input은 2가 되고 3월이면 input은 3이 된다. 이러한 경우에는 직관적으로도 input과 output은 선형을 만족할 것이라는 것을 알 수 있다.

즉 여기서 말하는 바는 input 값을 어떻게 표현하냐가 매우 중요하게 작용할 수 있다는 것이다. 이러한 input을 표현하는 과정을 Feature Extraction(특징 추출)이라고 표현한다.

이러한 특징 추출은 우리가 해결할 문제의 영역에 대한 깊은 이해를 필요로한다.

NLP를 위한 CNN (5): Character-level Convolutional Network for Text Classification

2018-08-09T04:47:35+00:00

NLP에서 활용되는 Convolutional Network에 대해서 논문 하나씩 알아보도록 한다. 전체 List는 다음과 같다.

Character-level Convolutional Network for Text Classification

다섯 번째로 소개할 NLP를 위해 CNN을 활용한 모델은 Xiang Zhang, Junbo Zhao, Yann LeCun의 Character-level Convolutional Network for Text Classification이다.

이때까지의 Convolutional neural network를 활용한 모델들은 input값의 최소단위를 단어(embedded word vector)였다. 하지만 이번 논문에서는 character(글자)단위의 convolutional neural network를 사용해서 문서 분류 문제를 해결하려 한다. 문서 분류문제에서 주류를 이뤘던 모델들은 보통 word2vec으로 임베딩된 단어 벡터들 그리고 TFIDF 정보 혹은 n-gram 정보들을 취합한 Bag of Word 모델들이 주를 이뤘다. 해당 논문에서는 단어보다 좀더 raw한 정보인 글자에 주목한다. 좀 더 근본적인 언어 구조의 특징을 뽑아내려는 시도이다. Charater단위를 ConvNet에 적용시킨 최초의 논문인 만큼 어떤 내용을 담고 있는지 살펴보도록 하자.

Introduction

만약 매우 큰 데이터셋으로 학습한다면 ConvNet은 단어에 대한 정보를(통사론, 의미론적이 정보를 포함한) 필요로 하지 않는다. 그리고 이렇게 character 단위로 만들어진 모델은 조금의 수정으로도 여러 언어에 적용 될 수 있고, 오타 혹은 이모티콘 또한 일반적인 단어와 마찬가지로 잘 학습될 수 있다는 장점이 있다.

Character-level Conovolutional Networks

해당 단원에서는 character-level ConvNet의 design에 대해서 소개한다. 해당 모델은 모듈식으로 구성되어 있다.

Key-Module

가장 핵심적인 부분은 temporal convolutional 모듈이다. 이 모듈은 1-D Convolutional 을 계산한다. discrete한 input 함수를 $g(x)\in[1,l]\rightarrow\mathbb{R}$ 라 하고 discrete한 kenel 함수를 $f(x)\in[1,k]\rightarrow\mathbb{R}$ 라 하자. 그러면 Convolution은 $h(y)\in[1,\lfloor(l-k)/d\rfloor+1]$ 라는 함수로 표현될 수 있고, Conovlution은 모든 input에 대해 kenel이 모두 계산되는 것이므로 함수는 아래와 같이 정의 된다.

$h(y)=\sum^k_{x=1}f(x)\cdot g(y\cdot d-x+c)$

위에서 사용된 상수 $c$ 는 $c=k-d+1$ 로 offset 상수 이다. Vision에서 흔히 사용되는 Convolutional network처럼 이 모듈은 kernel 함수들의 집합을 파라미터로 가진다. input $g_i(x)$ 에 대해서 output $h_j(y)$ 로 갈 때 계산되는 파라미터를 다음과 같이 정의한다.

$f_{ij}(x) ,i=1,2,...,m~\&j=1,2,...,n$

위의 파라미터를 weight 라 부른다. 그리고 위의 input, output값인 $g_i,h_j$ 는 feature 라고도 불리며, 전체 길이에 해당하는 $m, n$을 feature 라 한다. 즉 다시말해 output $h_j(y)$ 는 모든 $i$에 대해서 $g_i(x)$ 와 $f_{ij}(x)$ 를 convolution 연산한 것을 더하면서 얻어진다.

그리고 이 깊은 모델을 학습하는데 또 중요한 모듈은 max-pooling 모듈이다. input 함수를 $g(x)\in[1,l]\rightarrow\mathbb{R}$ 라 하고 max-pooling 함수를 $h(y)\in[1,\lfloor(l-k)/d\rfloor+1]\rightarrow\mathbb{R}$ 이라 하면 이 함수는 다음과 같이 정의 된다.

$h(y)=\max^k_{x=1}g(y\cdot d-x+c)$

여기서도 $c$는 offset 상수인 $c=k-d+1$ 이 된다. 이러한 max-pooling 모듈 덕분에 전체 모델은 총 6 layer만큼 깊어 질 수 있다.

(수식으로 설명되서 어렵게 느껴질 수 있는데 우리가 흔히 아는 convolution과 padding을 생각하면 된다,)

그리고 non-linearity를 위한 함수로는 ReLU 함수를 사용했다. 그리고 학습과정에서는 128 크기의 minibatch로 Stochastic gradient descent(SGD)를 사용했으며 모멘텀을 사용해 update했다. 모멘텀 사용 시 모멘텀 상수는 0.9로 하였고 학습률은 0.01 시작해서 3에폭마다 절반으로 줄이는 방식을 사용했다. 그리고 각 에폭은 각 class에 대해 동일하게 추출된 특정 크기의 데이터를 뜻하고 이 값에 대해서는 각 dataset에 따라서 다르므로 뒤에서 설명한다.

Character quantization

모델에서 인코딩된 글자(character)들의 sequence를 input값으로 받았다. 여기서 인코딩은 m개의 알파벳에 대해 one-hot 인코딩 방식을 사용했다. 따라서 각 input은 m-dimension의 벡터가 된다. 만약 알파벳에 들어가지 않는 문자에 대해서는 0벡터로 만든다. 그리고 특정 길이까지만 input으로 입력받는데, 길이를 넘어가는 값에 대해서는 무시한다. 이 모델에서는 알파벳을 총 70개의 문자로 정의한다. 알파벳에 속하는 문자는 26개의 영어 문자, 10개의 숫자, 그리고 33개의 특수문자이다. 전체 알파벳은 다음과 같다.

여기서는 영어 문자에 대해서는 소문자만 받도록 했는데 나중에 소문자와 대문자를 구별하는 것과도 비교할 것이다.

Model Design

2개의 ConvNet을 design했다. 하나는 많은 feature를 가지는 ConvNet이고 하나는 적은 feature를 가지는 ConvNet이다. feature의 개수를 제외하고는 다른 부분은 모두 동일하다. 전체 모델은 총 9개의 layer이고 그 중 6개는 convolutional layer이고 3개는 fully-connected layer이다.

세부적인 사항에 대해서 살펴보면 input의 feature의 수는 70이다. 앞서 설명한 encoding 방식을 사용하면 한 문자당 70 dimension의 vector가 되기 떄문이다. 그리고 앞서 말한 것 처럼 특정 길이까지의 문자만 입력으로 받는데 여기서는 1,014개의 문자까지만 입력으로 받는다. 논문에 따르면 이 정도 길이면 글의 주된 내용은 모두 잡아낼 수 있다고 한다. 그리고 앞서 말한 것처럼 feature의 수가 다른 2개의 ConvNet을 design 했다고 했는데, Large feature는 Convolution을 통해 총 1024의 feature를 가지는 Convolution을 수행하고 small feature는 256의 feature를 갖도록 convolution을 수행했다. 즉 다른 필터의 사이즈를 사용했다고 이해하면 된다. 아래의 표는 각 Convolutional layer의 값들을 설명했다. (참고로 stride는 1이고 pooling과정에서 overlap되는 부분이 없도록 한다)

그리고 fully-connected layer 사이에 dropout을 2번 사용했다. dropout 확률은 0.5로 설정했다. 그리고 가중치 초기화는 가우시안 분포를 따르도록 하고 분포의 평균과 분산은 큰 모델에 대해서는 (0, 0.02)로 작은 모델은 (0, 0.05)로 설정했다.

Data Augmentation using Thesaurus

데이터 증가는 일반적으로 데이터가 많이 필요한 deep learning 에서는 매우 중요한 부분이지만, image나 speech 분야와는 달리 text에서의 데이터 증가는 문자의 순서가 매우 중요할 수 있는데, 이런 언어의 규칙을 데이터를 증가시키면서 손상시킬 수 있기 때문에 조심스럽다. 따라서 여기서 사용한 데이터 증가 방식은 단어나 특정 문자들을 유사어로 대체시키는 방법을 사용했다.(English thesaurus를 사용했다.)

Comparison Models

비교를 위한 모델로는 전통적인 NLP 방식과 Deep Learning 방식 두가지 모두 사용해서 비교했다. 각 모델은 다음과 같다.

Traditional Methods

Bag of words and its TFIDF
Bag of ngrams and its TFIDF
Bag of means on word embedding

Deep Learning Methods

Word based ConvNets
Long short term memory

Dataset and Result

비교를 위해 사용한 데이터셋은 다음과 같다.

AG’s news corpus
Sogou news corpus
DBPedia ontology dataset
Yelp reviews
Yahoo! AAnswers dataset
Amazon reviews

데이터셋에 대한 세부적인 설명은 생략한다. 6개의 데이터셋 중에서 앞의 3개는 비교적 작은 크기의 데이터셋이고 뒤의 3개는 큰 데이터셋이다.

그리고 결과는 다음과 같다. 각 모델에 명명에 대해서 설명하면 Lg 와 Sm은 Large와 small을 의미하고, Lk는 Look-up table을 사용한 것이다. 그리고 Th는 앞서 말한 Thesaurus를 의미한다.

이제 결과에 대해서 몇 가지만 요약하면 다음과 같다.

글자 단위의 Convolutional Network도 문서 분류에서 높은 성능을 보인다.
작은 데이터셋에서는 전통적인 NLP방식이 DL방식보다 더 높은 성능을 보인다.
ConvNet은 사용자가 만든 데이터에서 좋다.(오타를 잘 잡는다)
Alphabet의 선택에 따라 성능이 많이 달라진다.
Bag-of-means 모델은 안좋다.
모든 데이터셋에 있어 최적의 모델은 없다.( 많은 실험을 통해 데이터셋에 가장 적합한 모델을 찾아야 한다)

NLP를 위한 CNN (4): A Sensitivity Analysis of Convolutional Neural Networks for Sentence Classification

2018-08-06T04:47:35+00:00

NLP에서 활용되는 Convolutional Network에 대해서 논문 하나씩 알아보도록 한다. 전체 List는 다음과 같다.

A Sensitivity Analysis of Convolutional Neural Networks for Sentence Classification

이 논문은 CNN을 활용한 새로운 구조의 모델을 소개하는 논문이 아니라, CNN을 활용해서 Sentence Classification을 위한 모델을 만들 때 선택해야할 여러 Hyperparameter들의 선택을 돕기 위해 여러 가지를 비교하며 보여주는 논문에 가깝다.

CNN의 경우 학습과정이 빠르지 않기 때문에 다향한 Hyperparameter들의 실험하는 것이 어렵다. 따라서 이 논문에서 소개하는 내용을 참고하는 것이 속도 및 효율측면에서 도움이 된다. 여기에서 실험해본 요소로는 다음의 것들이 있다.

input word 표현(embedding)
filter의 region size
feature map의 수
activation function
pooling 전략
정규화 방법

CNN Architecture

여기에서는 Architecture의 경우 세부적인 내용은 계속해서 바뀌므로 일반적인 부분에 대해서 소개한다. 우선은 1-layer CNN을 사용했으며, input값에 대해서 먼저 알아보자.

input값은 각 문장을 tokenize한 뒤 각 단어를 embedding 한 벡터로 만들어서 단어 벡터들을 합친 matrix가 된다. embedding 방법으로는 word2vec과 glove를 사용했다. 그리고 벡터의 dimension은 $d$라 한다.

그 다음으로는 convolution의 filter에 대해서 설명하면, filter의 넓이(width)는 건들지 않고 $d$로 고정시켰다. 단어 임베딩의 dimension이 $d$이기 때문에 이 부분은 수정하지 않고 높이(height)만 수정했다. 즉 filter가 몇개의 단어를 보는지를 바꾸면서 실험했다. 이 부분이 의미하는 것이 필터의 region size이다.

필터를 적용시킨 후 bias( $\mathbf{b}$ )를 더하고 activation fucntion( $f$ )를 각 요소에 사용했다.

다음으로는 풀링을 적용시킨다. 일반적인 방법은 1-max pooling으로 각 feature map에 대해서 하나의 scalar값을 뽑는 방법이다. 풀링의 결과인 filter map으로 부터 만들어진 output을 고정된 길이로 concatenate한다. 이후 classification을 위해 softmax함수를 사용한다. 여거서 정규화를 위해 dropout을 사용할 수 있다. 또 l2 norm 정규화도 사용 될 수 있다. 아래의 그림이 위의 여러 경우의 Architecture를 하나로 설명한 그림이다.

이제 학습과정이 남았다. 우선은 Objective funciton으로는 cross-entropy loss함수를 사용한다. 그리고 optimization으로는 SGD와 back-propagation을 사용한다.

DataSets

하나의 데이터셋으로 비교할 경우 정확한 결과를 얻기 힘드므로 여러 데이터셋을 사용해서 비교한다. 사용한 데이터셋은 다음과 같다.

MR
SST-1
SST-2
Subj
TREC
CR
MPQA
Opi
Irony

Effect of each factor

각각의 요소에 의한 영향들을 비교 분석하면서 확인해보자.

Effect of input word vector

가장 먼저 word vector represent 방법에 따른 영향을 분석해보자. 앞서 말했듯이 방법은 word2vec과 glove로 학습된 벡터를 사용한 뒤 비교하는 것이다. word2vec의 경우 1000억개의 google news의 단어를 학습한 벡터이고 glove는 web의 8400억개의 token을 학습시켰다. 두 방법 모두 300dimension의 벡터로 만들었으며 학습 중간에 update하지는 않았다. 그리고 word2vec과 glove를 concatenate한 벡터도 input으로 사용해서 실험을 했다. 즉 600 dimension의 vector로 사용한 것이다. 결과는 다음과 같다.

결과를 보면 word2vec과 glove의 경우 dataset에 따라 성능이 좋은 것이 다르고 보통은 크게 차이가 나지 않았다. 하지만 word2vec과 glove를 concatenate한 것은 생각보다 성능이 좋게 나오지는 않았다.

그리고 위의 결과에는 나와있지 않지만 one-hot encoding방식으로도 실험을 진행했지만 embedding방법에 비해 성능이 나오지 않았다.

Effect of filter region size

filter가 적용되는 크기인 region size를 1, 3, 5, 7, 10, 15, 20, 25, 30의 크기를 두고 비교했다. 결과를 보면 각 데이터셋에 맞는 최적의 region size가 있다는 것을 알 수 있다. 데이터의 sentence길이가 길수록 이 최적의 region size의 길이는 길어지는 경향이 있다.

그리고 region size를 단일값으로만 사용하지 않고 여러 size를 사용해서 실험 한 결과는 다음과 같다.

결과를 보면 region size를 여러개 사용한다고 크게 성능에서 차이가 나지 않음을 보인다. 가장 높은 효율을 보일 때는 모든 region size를 동일하게 7로 했을 때이다.

Effect of number of feature maps for each filter region size

여기서는 region 크기는 3,4,5로 고정을 하고 feature map의 수를 10, 50, 100, 200, 400, 600, 1000, 2000으로 둬서 비교했다. 여기서도 마찬가지로 각 데이터셋에 맞는 최적의 feature map수가 있다는 것을 볼 수 있는데 그래도 하나의 경향성은 보통 feature map 수가 600까지는 성능이 증가한다는 것을 볼 수 있다.

Effect of activation function

활성화 함수로는 ReLU, tanh, sigmoid, softplus, cube, tanh cube, 그리고 ‘iden’으로 identitiy function도 사용했다. 결과는 다음과 같이 나온다.

9개의 데이터셋 중 8개의 데이터셋에서 Iden, ReLU, tanh중 하나가 가장 최적의 활성화 함수였다. 그리고 MPQA데이터셋에서는 SoftPlus가 다른 데이터에 비해 성능이 월등히 좋게 나왔다. 나머지 활성화 함수의 경우 다른 앞서 말한 활성화 함수들에 비해 성능이 나오지 않아서 표에서 확인할 수 없다. 결과에 대해서 분석을 해보자면 tanh의 경우 함수가 zero-centered한 성질이 있기 떄문에 좋은 성능을 보인 것 같다. 그리고 ReLU의 경우 sigmoid에 비해 non-saturating 한 성질이 도움이 된다. 그리고 SGD와 사용시 수렴하는 속도가 매우 빠르다. 한 가지 흥미로운 결과는 항등함수(identity)가 경우에 따라 좋은 결과를 만들기도 한다는 점이다. 그러나 만약 multiple hidden layer를 가진 network이라면 항등함수의 경우에는 non-linear이기 떄문에 적합하지 않다.

Effect of pooling strategy

Pooling의 경우에는 pooling region size와 strategy를 변경하며 실험했다. region size는 3, 10, 20, 30, 1-max pooling을 사용했고, 5, 10, 15, 20의 값에 대해 $k$-max pooling도 사용했다. 그리고 3, 10, 20 ,30의 region size로 average 풀링도 적용했다.

실험 결과는 average pooling이 일반적으로 max pooling보다 성능이 좋지 않았고 분석 결과 1-max pooling이 sentence classification에서는 좋은 성능을 보인다.

Effect of regularization

여기서는 dropout과 $l2$ regularization을 분석했다. 일반적으로 $l_2$ norm constraint는 성능을 향상시키지 못했다. 그리고 dropout의 비율을 다르게 하는 것 또한 성능변화가 크게 일어나지 않았다. 다음으로는 dropout을 penultimate layer가 아닌 convolutional layer에 적용시켰을 때는 성능이 조금은 좋아졌다. 결과적으로 이 논문에서는 dropout rate를 0~0.5정도로 적은 값으로 설정하고 상대적으로 max norm의 경우에는 크게 설정하라고 추천한다.

Conclusion

이 논문을 통해 본 결과 모든 요소들이 데이터셋과 다른 요소들에 의해서 좋고 나쁨이 명확하지는 않다. 하지만 성능에 크게 영향을 미치는 요소는 실험을 통해 tuning할 필요가 있다는 것을 의미한다. 튜닝이 필요한 hyperparameter는 우선 filter의 regionsize이다. 그리고 feature map의 수 또한 성능에 많은 영향을 미치므로 tuning이 필요하다. 나머지의 경우 얘기를하면 word representation은 word2vec 과 glove가 다른 방법들에 비해 classifcation에서는 월등한 성능을 보이므로 두 가지 중에서 사용하는 것이 좋다. 그리고 풀링은 1-max pooling이 적합하다. 마지막으로 regularization은 상대적으로 다른 요소들에 비해 영향이 적으니 크게 고려하지 않아도 된다.

NLP를 위한 CNN (3): A Convolutional Neural Network for Modelling Sentences

2018-08-06T04:47:35+00:00

NLP에서 활용되는 Convolutional Network에 대해서 논문 하나씩 알아보도록 한다. 전체 List는 다음과 같다.

A Convolutional Neural Netwrok for Modelling Sentences

Oxford의 Kalchbrenner에 의해 발표된 이 논문에서 소개하는 CNN은 Dynamic Convolutional Neural Netwrok(DCNN)으로 Dynamic k-Max Pooling을 사용한다. 그리고 가변 길이의 sentence를 input으로 받으며, feature graph를 만들어서 short term과 long term의 특징을 모두 사용한다. 아래의 그림을 보자.

이 네트워크를 가지고 4가지 실험을 했다.

binary classification
multi-class sentiment classification
six-way question classification
twitter sentiment prediction

결과를 먼저 말하자면 논문의 네트워크를 사용함으로써 위의 모든 tasks에서 높은 성능을 보여줬고 1,2,3번의 경우에는 기존의 baseline보다 25%나 상승된 성능을 보여줬다.

논문에서 사용된 sentence model은 classification과 generation을 위해 만들어 졌으며, 문장 내용의 의미를 표현하거나 분석한다. 다양한 task에 해당 모델을 활용할 수 있다.

이제 model의 특징에 대해서 알아보도록 하자.

Convolutional Neural Networks with Dynamic $k$-Max Pooling

해당 논문에서는 wide-convolution을 k-max pooling 을 사용하는dynamic pooling layer로 대체한다. 이 모델의 input이 가변 길이의 sentence를 받기 때문에 중간 layer에서의 feature map의 넓이는 각각 다르다. 하지만 CNN의 경우 고정 크기의 map에 대해서 연산할 수 있다. 이러한 문제를 해결하기 위한 것이 Dynamic Convolutional Neural Netwrok이다. DCNN을 그림으로 나타내면 다음과 같다.

Wide Convolution

주어진 input 문장에 대해서 각 단어의 임베딩값을 구한다.

$\mathbf{w}_i\in\mathbb{R}^d$

만들어진 임베딩 벡터를 concatenate해서 문장 matrix를 만든다.

$\mathbf{s}\in\mathbb{R}^{d\times s}$

여기서 각 단어 벡터 $\mathbf{w}_i$ 는 학습 과정에서 최적화 될 것이다. convolutional layer는 weight matrix인 $\mathbf{m}\in\mathbb{R}^{d\times m}$ 를 convolution한다. 여기서 dimension $d$와 필터의 넓이인 $m$은 hyper parameter이다. 이 과정을 wide one-dimensional convolution이라 한다. 그리고 이 결과 나오는 matrix를 $\mathbf{c}$라 하고 dimension은 $d\times(s+m-1)$이 된다.

k-Max Pooling

여기서 사용할 Pooling연산은 Max-TDNN 문장 모델에서 사용된 max pooling over the time dimension을 사용한다. 이 연산은 일반적인 일부 지역은 모아 pooling하는 것과는 다른 연산이다. 과정에 대해 설명하면 우선 어떤 $k$ 값이 주어진다. 그리고 $p\ge k$ 인 dimension을 가지는 sequence(vector) $\mathbf{p}$ 에 대해서 $k$ -max pooling은 sequence $\mathbf{p}$ 에서 $k$ 개의 최대 값을 선택해 subseqeunce $\mathbf{p}^k_{max}$ 를 만든다.

$k$-max pooling은 위치가 가까운것에 신경쓰지 않고 $\mathbf{p}$ 에서 k개의 active한 값을 뽑아낸다. 그리고 연산을 한 후에는 각 feature의 정확한 위치 정보는 소실되지만 각 feature들간의 순서 정보는 보존된다. 이 $k$-max pooling 연산은 해당 네트워크에서 가장 위에있는 convolutional layer이후에 적용된다. 이 연산을 통해 jully connected layer로 가기 위한 input값의 크기 제한이 없어진다. 다음으로 우리가 알아볼 pooling은 convolutional layer 중간에서 적용되며 $k$값이 고정되어 있지 않고 더 넓은 범위의 순서를 보존하며 뽑기위해 동적으로 선택된다.

Dyanmic $k$ -Max Pooling

dynamic k-max pooling 연산은 k-max pooling과 같은 과정으로 수행되지만 k값이 정해지는 함수가 존재한다. 이 함수는 문장의 길이와 네트워크의 총 깊이(전체 레이어의 수)에 의해 결정된다. 문장 길이를 $s$라 하고 네트워크의 깊이는 $L$이라 한다. 이 떄 함수는 다음과 같다.

$k_l=\max(k_{top}, \lceil \frac{L-l}{L}s\rceil)$

여기서 $l$은 현재 convolutional layer의 층이다. 그리고 $k_{top}$은 가장 높은층의 convolutional layer를 위한 고정된 parameter이다. 예를 들어보자. 전체 3개의 convolutional layer가 있고, $k_{top}=3$ 이고 input 문장의 길이는 $s=18$ 이라 하자. $k$값들은 다음과 같다.

$\begin{align*} &k_1= \max(3 , \lceil \frac{3-1}{3}\cdot18\rceil)=12\\ &k_2= \max(3 , \lceil \frac{3-2}{3}\cdot18\rceil)=6\\ &k_3= k_{\max}=3 \end{align*}$

이 Pooling에 대해서 조금 직관적으로 이해를 해보자. k값은 층이 올라갈 수록 수가 적어지는 구조이다. 이 구조가 의미하는 것은 층이 낮은 곳에서는 더 많은 중요한 feature를 뽑고 층이 올라갈 수록 더욱 중요한 feature를 고르는 과정으로 이해할 수 있다.

Non-linear Feature Funciton

위의 $k$-max pooling 연산은 conovlution 연산의 결과에 적용된다는 것을 알 수 있다. 이렇게 pooling을 한 이후에 바로 값을 다음으로 보내는 것이 아니라 bias $\mathbf{b}\in\mathbb{R}^d$ 를 더하고 non-linear 함수인 $g$ 를 요소별로 적용 시킨 후 적용시킨 후 다음 층으로 전달 된다. 각 pooling matrix에서는 각각의 단일 값의 bias가 존재한다.

Multiple Feature Maps

이때까지는 우리는 각 layer에서 convolution과 pooling이 하나씩만 적용되는 경우로 생각했다. 하지만 처음에 봤던 전체 network에 대한 그림을 보면 알 수 있듯이 각 layer에서 2개씩 적용된다. 즉 여러개의 feature map을 만든 뒤 만든 feature map을 새로운 parameter를 곱한 뒤 합쳐주는 형태이다.

$\mathbf{F}^i_j=\sum^n_{k=1}\mathbf{m}^i_{j,k}* \mathbf{F}^{i-1}_k$

여기서 *가 의미하는 것은 wide convolution이다. 실제 netwrok에서 병렬로 진행하는 모델의 수는 그림처럼 꼭 2개는 아니고 사용자가 정하는 것이다.

Folding

이때까지의 모델을 살펴보면, feature map을 뽑을 때 convolution과 pooling이 모두 각 row에 대해서 연산되는 것을 볼 수 있다. 이렇게 진행을 한다면 각 row는 독립적으로 진행되어서 서로 연관관계에 대한 정보는 전혀 포함 할 수 없다. 따라서 이러한 row-independent한 문제를 해결하기 위해 연산을 마친 각 row들을 합치는 folding과정을 마지막 pooling 전에 수행한다. 2개의 row를 각각 합하는 형태로 진행되기 때문에 새로운 parameter도 필요하지 않다. 이 과정을 수행하면 matrix의 높이가 절반으로 줄어드게 된다.

Properties of Sentence Model

해당 네트워크의 sentence modeling의 몇 가지 특성에 대해서 소개한다.

Word and n-Gram Order

stence modeling에서 중요한 것은 특정 n-gram이 input에서 발생하는 것을 구별하는 것과 구별한 n-gram에 대해서 상대적인 순서 정보 또한 가지고 있는 것이 중요하다. 해당 netwrok는 두 중요점을 위해 설계했다. $\mathbf{m}$ 필터로 wide convolution을 하면 특정 n-gram에 대한 정보를 뽑고, pooling과정에서 각 순서 정보를 포함하게 된다.

Induced Feature Graph

해당 모델을 좀 더 큰 그림으로 보자. 우선 각 matrix의 하나의 row의 관점에서만 보게 된다면 각 값들 중 몇 가지만 선택되서 다음 layer로 전달 된다. 나머지 값들은 탈락된 것이며 선택된 값들 중 그 다음으로 또 전달 되는 것은 그 일부이다. 이러한 내용을 전체적으로 보면 각 값(feature)에 대한 graph 구조로 생각할 수 있다. 이 글의 시작에서 소개한 그림의 형태로 진행되고 있는 것이다.

Train

학습에 사용된 방법들에 대해 소개하면 다음과 같다.

top-layer는 softmax를 통해 예측한 class에 대한 확률 분포를 가진다. 학습과정에서 이 분포에 대해 실제 분포와 비교해서 cross-entropy를 최소화하는 방향으로 학습한다.
학습 시 $L_2$ 정규화를 사용했다.
mini-batch 방식으로 학습시켰다.
update policy는 Adagrad를 통해 update했다.

Expreriments

실험은 다음의 4가지 문제에 대해서 진행했다.

Sentiment Prediction in Movie Review
Question Type Classification
Twitter Sentiment Prediction with Distant Supervision
Visualising Feature Detectors

각 task들에 대한 결과는 다음과 같다.

Sentiment Prediction in the movie reviews dataset

Six-Way Question Classification on TREC

Twitter Sentiment Prediction

Feature Detectors

NLP를 위한 CNN (2): Convolutional Neural Network for Sentence Classification

2018-08-05T04:47:35+00:00

NLP에서 활용되는 Convolutional Network에 대해서 논문 하나씩 알아보도록 한다. 전체 List는 다음과 같다.

Convolutional Neural Network for Sentence Classification

가장 먼저 소개할 논문은 Newyork 대학의 Yoon kim님의 논문인 Convolutional Neural Network for Sentence Classification입니다. 매우 간단한 구조의 CNN을 활용해서 문장 분류에서 상당한 효율을 보이며 많은 주목을 받았던 논문입니다.

자연어 처리 분야에서 딥러닝 기법을 활용한 중요한 기술은 단어 표현을 학습하는 것이다. 즉 one-hot 벡터로만 사용하던 단어표현이 word2vec, Glove등 많은 기술들을 통해 dense한 low-dimension vector로 표현함으로써 비슷한 의미의 단어는 가까운 거리(유클리디언 거리 혹은 코사인 유사도)에 있도록 만들었다.

그리고 CNN은 원래는 Computer vision분야의 문제를 해결하기 위해 나왔지만 많은 NLP 문제에서도 효과적이라고 알려졌다. 이 논문에서는 한개의 layer를 사용하는 CNN에 대해서 소개한다. 그리고 CNN에 사용할 단어 벡터는 1,000억개의 단어를 사전학습한 벡터를 사용한다. 여기서는 이 벡터를 수정하거나 하지 않고 Network의 parameter만 학습한다. 우선 사용할 architecture에 대해서 보자.

Model

위의 architecture는 Collobert(2011)의 architecture를 약간 수정한 것이다. 세부적으로 하나씩 알아보자.

우선 input은 $k$-dimension의 단어 벡터이다. 문장의 $i$번 째 단어는 다음과 같다.

$x_i\in\mathbb{R}^k$

그리고 문장은 $n$개의 단어를 concat하여 사용하는데, 필요하다면 padding을 추가한다. 따라서 다음과 같이 표현된다.

$\mathbf{x}_{i:i+j}=\mathbf{x}_i\oplus \mathbf{x}_{i+1}\oplus ... \oplus \mathbf{x}_{i+j}.$

위의 $\oplus$는 concatenation 연산자이다. 위의 sentence에 convolution을 한다. 필터는 $hk$크기의 벡터의 모양이다. $h$개의 단어에 적용되서 새로운 feature를 뽑아낸다.

$\mathbf{w}\in\mathbb{R}^{h\times k}$

convolution 연산을 하면 feature $c_i$가 만들어진다.

$c_i=f(\mathbf{w}\cdot \mathbf{x}_{i:i+h-1}+b)$

여기서 $b\in \mathbb{R}$는 bias이고 $f$는 tanh와 같은 non-linear 함수이다. 이 필터는 sliding하면서 sentence $[\mathbf{x}_{1:h},\mathbf{x}_{2:h+1},...,\mathbf{x}_{n-h+1:n}]$ 에 대해서 각각 적용되서 feature map $\mathbf{c}$ 를 만든다.

$\mathbf{c}=[c_1,c_2,...,c_{n-h+1}] \in \mathbb{R}^{n-h+1}$

만들어진 feature map에 max-over-time pooling(Collobert et al., 2011)을 하고 최대 값을 뽑아낸다.

$\hat{c}=\max\{\mathbf{c}\}$

위 값은 특정 필터에 상응하는 feature가 된다. feature map에서 가장 중요한 값(높은 값)을 뽑아내는 방법이다. 이러한 방법을 사용하면 하나의 필터에 대해서 하나의 feature를 뽑아 낸다. 이러한 피쳐들은 penultimate layer를 구성하고 fully connected sofmax layer로 통과시켜서 라벨에 대한 확률 분포를 만들어 낸다.

그리고 마지막으로 그림을 보면 input에서 2개의 channel이 존재한다. 하나는 위에서 설명한 static한 word vector들을 모아둔 것이고, 나머지는 backpropagation을 통해 fine tuning 한 것이다. 즉 두 개의 channel에 대해서 filter를 적용시킨 후 더해서 사용한다. 1개의 channel만 사용한다면 더하는 과정 없이 바로 사용하면 된다.

Regularization

여기서는 정규화를 위해 dropout과 l2-norm 정규화를 사용했다. dropout의 경우에는 penultimate layer에서 마지막 layer로 가는 파라미터에서 사용했는데 이를 사용함으로써 hidden unit들이 같이 더해지는 것을 방지한다. forward와 back propagation에서 모두 사용했다. 즉 일반화해서 나타내면, penultimate layer를 $\mathbf{z}=[\hat{c}_1,…,\hat{c}_m]$이라 하자. 그러면,

$y=\mathbf{w}\cdot\mathbf{z}+b$

를 사용하는 대신에, 아래의 식을 사용했다.(in forward)

$y=\mathbf{w}\cdot(\mathbf{z}\odot\mathbf{r})+b$

여기서 $\odot$은 원소별 곱샘을 뜻하고 $\mathbf{r}$은 ‘masking’ 벡터로 각 값이 확률 $p$의 Bernoulli분포를 따르기 때문에 0 혹은 1의 값을 가진다. test과정에서는 dropout을 하지 않고 $\mathbf{w}$ 대신에 dropout 확률 $p$를 곱해서 사용한다. $\hat{\mathbf{w}}=p\mathbf{w}$

그리고 $l_2$ 정규화의 경우 가중치 벡터의 $l_2$ norm이 $s$보다 클 경우 $s$값을 가지도록 조정한다.

$\mathbf{w}= \begin{cases} w, ~\text{if }{\|\mathbf{w}||}_2<s\\ s, ~\text{other wise} \end{cases}$

DataSet

이 논문에서 사용 된 데이터셋은 다음과 같다.

MR : 리뷰당 하나의 문장으로 된 영화 리뷰
SST-1 : Stanford Sentiment Treebank (label이 세분화)
SST-2 : Stanford Sentiment Treebank (label이 binary)
Subj : 주관성 데이터셋
TREC : TREC 질문 데이터셋
CR : 소비자 리뷰 데이터셋
MPQA

학습과 그 외 기타 사항들

이 모델에서 사용한 hyperparameter 및 함수는 다음과 같다.

ReLU 함수
100 feature map으로 filter의 크기는 3,4,5로 지정
Dropout 확률 : 0.5
$l_2$ 값 : 3
미니 배치 크기 : 50

그리고 early stopping이 추가적으로 사용된 것 외에는 다른 특별한 사항은 없다. 그리고 학습 과정에서는 무작위의 mini batch에 대해서 SGD를 사용했고(엄밀히 말하면 MGD를 사용한 것이다), 파라미터 업데이트는 Adadelta를 사용했다.

단어 벡터의 경우는 앞에서 나왔듯이 google news를 활용해 word2vec으로 사전 학습된 임베딩 벡터를 사용했으며 만약 vocabulary에 들어가 있지 않은 단어의 경우에는 임의의 값으로 초기화해서 사용했다. 그리고 실험단계에서 여러가지 상황을 바꿔가며 성능을 비교했는데 아래의 종류로 구분지어서 실험했다.

CNN-rand : baseline값으로 사용하기 위해 사용. 모든 단어 벡터를 임의의 값으로 초기화해서 사용했다.
CNN-static : 앞서 말한 사전 학습된 word2vec 단어 벡터를 사용한 모델이다.
CNN-non-static : 위의 모델과 같이 학습된 벡터를 사용했지만 각 task에서 벡터값은 update된다.
CNN-multichannel : architecture 소개 부분에서 나왔듯이 input값을 1-channel로 한 것이 아니라, 2-channel인 모델. 둘 다 word2vec으로 학습한 단어 벡터인데 하나는 static하게 값이 그대로이고 나머지 하나는 학습 중간 계속 update된다. 즉 위의 static과 non-static을 섞어서 사용한 것과 같다.

이렇게 4개의 경우로 나눠서 실험 했으며 결과는 다음과 같다.

표의 상위 4개가 비교하는 모델이고 아래의 값들은 다른 모델의 값을 비교한 것이다. 결과를 보면 절대적으로 좋은 모델은 없고 데이터셋에 따라 좋은 결과를 보이는 모델이 다르다. 하지만 명확한 것은 CNN을 활용해 만든 매우 간단한 모델임에도 불구하고 다른 모델들과 비교해서도 결코 적지 않은 성능을 보이거나 아니면 오히려 뛰어난 성능을 보여준다.

이번 논문의 내용만 보더라도 CNN은 Image에서만이 아니라 자연어 처리 분야에서도 쉽고 간단하게 높은 성능을 기대할 수 있다. 그리고 이 논문을 통해 알게 된 또 하나의 사실은 word2vec등 단어를 임베딩하는 것이 NLP분야에서는 필수적이고 그 자체만으로도 성능이 엄청 오른다는 것을 알 수 있다.

NLP를 위한 CNN (1): Understanding CNN for NLP

2018-08-03T04:47:35+00:00

NLP에서 활용되는 Convolutional Network에 대해서 논문 하나씩 알아보도록 한다. 전체 List는 다음과 같다.

첫 번째로는 논문이 아닌 NLP에서 사용되는 CNN에 대한 대략적인 이해를 위해 CNN의 NLP에서의 활용에 대한 설명을 할 것이다. 해당 내용은 제가 직접 구성한 내용이 아니라 블로그 글를 번역하고 나름 정리해서 쓴 글입니다. 의역이 포함되고 혹여나 오역이 있을 수 있어 원문과 비교하면서 읽으시는 것을 추천합니다!

Understanding Convolutional Neural Network for NLP

일반적으로 우리가 CNN를 생각하면 Computer Vision 분야를 대부분 떠올릴 것이다. 실제로 CNN은 Computer Vision 분야에서 많은 발전을 이뤘다. Image Classification, Image Detection, Semantic Segmentation 등 많은 분야에서도 CNN을 활용해서 성능 발전을 보여준 사례가 많다. 해당 분야에 대해서 좀 더 알고 싶다면 블로그 글을 참고하자.(Image Classification, Image Detection(1), (2) , Semantic Segmentation(1), (2))

좀 더 최근에는 CNN을 NLP문제에 활용하기 위한 많은 시도들을 했다. 사용한 NLP문제에서도 좋은 결과를 만들었다. 이 포스트에서는 CNN에 대한 내용을 간략히 소개하고 NLP에 CNN에 적용하는 방법에 대해 소개한다. CNN에 대한 직관적인 이해는 Computer Vision의 예를 들어 이해하는 것이 훨씬 쉬우므로 처음에는 Image를 예로들어 CNN에 대해서 알아보도록 한다.

Convolutional Neural Network (합성곱 신경망)

CNN은 window가 sliding 하며 Convolution 연산이 수행되는 과정이 포함된 네트워크이다. 아래의 그림은 Convolution하는 과정을 잘 보여준다.

CNN을 활용하는 예시를 생각해보자. 먼저 Image는 흑백이미지로 구성되며 각 pixel의 값은 0(black) 과 1(white) 값을 가진다고 하자. (일반적인 흑백 이미지는 0~255값을 가지는 grayscale이다.)

이제 이 Iamge는 Kernel, Filter, Feature detector라 불리는 window에 의해 합성곱이 이뤄질 것이다. 여기서는 3x3 크기의 필터를 사용했다고 생각하자. 이러한 Convolution 과정이 실제로 의미하는 바는 무었일까? 직관적인 이해를 위해서 다음의 두가지 의미로 해석할 수 있다.

픽셀값을 주변의 값들로 묶어 평균해서 Image를 흐리게 만든다.
주변의 pixel의 차이를 계산함으로써 edge를 찾는다.

좀 더 많은 예시는 GIMP manual에서 참고할 수 있다. 일반적인 CNN과정에 대해 더 알고 싶다면 포스트를 참고하자.

NLP문제에서의 CNN의 활용

Image Pixel대신 NLP문제를 해결할 때는 문장이나 전체 글을 matrix형태가 Input값이 된다. 이 matrix의 각 행은 하나의 token이 된다. token은 주로 단어가 된지만 경우에 따라 개별 문자가 하나의 token으로 활용하기도 한다. 즉 각 행은 단어 vector를 뜻한다. 대부분의 경우 이 단어 vector는 임베딩한 vector가 되는데 임베딩의 경우 word2vec 혹은 glove 기술을 통해 임베딩시킨 벡터이다. 경우에 따라 임베딩 시키지 않고 one-hot vector가 단어 vector가 될 수도 있다. 임베딩이든 one-hot이든 일단 벡터의 차원이 100차원이라 하고 token의 수, 즉 단어의 수를 10개라고 하면 이 matrix는 10x100 크기가 된다. 이 matrix가 우리의 “image”가 된다.

Vision 문제에서 필터는 image를 지역적으로 sliding한다. 그러나 NLP에서는 필터는 matrix의 모든 단어의 전체 행에 사용된다. 따라서 필터의 넓이는 보통 matrix의 넓이와 같다. 즉 단어벡터의 dimension과 같게 된다. 높이(or region size)는 달라지지만 보통의 경우 2~5개의 단어를 sliding한다. 위의 과정에 대해 아래 그림을 보며 좀더 정확히 이해해보자.

Computer Vision에서의 중요한 직관은 위치의 불변성과 지역적 결합이다. 그러나 NLP에 이러한 직관은 해당되지 않는다. pixel의 경우는 비슷한 위치에 있으면 거의 의미적으로도 비슷한 pixel이지만 단어의 경우에는 항상 이러한 경우가 성립하지는 않는다. 단어들은 몇 가지 방법으로 구성된다. 예를 들면 명사를 변형시킨 형용사와 같이 단어들이 어떤 규칙이 있다. 그러나 정확히 이러한 단어가 높은 단계에서 어떤 의미를 가지는지는 알기 어렵다.

이러한 모든 것들을 고려해볼때 CNN은 자연어 처리 분야에 적합하지 않아 보인다. Recurrent Neural Network가 훨씬 더 직관적으로 좋아보인다. RNN은 우리가 실제 언어를 사용하는 방법과 많이 비슷하다. 우리가 언어를 읽을 때도 왼쪽부터 오른쪽으로 순서대로 읽는 과정이 RNN과 비슷하다. 그러나 다행이도 이러한 내용이 CNN이 부적합하다는 것을 의미하지는 않는다. 다는 아니지만 몇몇의 모델은 유용하게 사용된다. Bag-of-Words 모델도 가정 자체가 지나치게 단순화해서 잘못된 가정이긴 하지만 그럼에도 불구하고 몇년동안 나름 좋은 결과를 만들어냈다.

CNN의 가장 큰 장점은 매우 빠르다는 것이다. 합성곱 자체가 컴퓨터 그래픽의 핵심적인 부분이고 GPU단계에서 잘 동작한다. n-gram모델같은 것들과 비교해서 CNN은 단어 표현에 효율적이다. 단어사전이 굉장히 큰 경우 3-gram만 해도 비용이 급격하게 증가한다. 심지어 구글조차 5-gram이상의 것들은 제공하지 않는다. Convolutional Filter는 전체 단어 사전 없이도 자동으로 좋은 단어표현을 학습시킨다. 그리고 이 필터의 크기가 5보다 크더라도 문제가 되지 않는다. 첫 번째 레이어에서 학습된 많은 필터가 n-gram과 유사하다고 생각한다. 그러나 조금 간결한 방법으로 표현한다.

CNN Hyperparameters

CNN이 어떻게 NLP 문제에 적용되는지 설명하기 전에 우선 Convolutional Neural Network를 만들 때 필요한 몇 가지 선택안에 대해서 살펴보자. 몇 가지 방안에 대해서 본다면 관련 분야에서 이해가 더 쉬워질 것이다.

Narrow vs Wide Convolution

위에서 Convolution을 설명할 때 자세한 내용은 생략했었다. 3x3 필터를 input의 중간에는 적용하는 것이 직관적이지만 가장 자리에는 3의 크기가 안나올 수 있다. 이런 경우는 어떻게 할까? 다들 알다시피 zero padding을 사용한다. 가장 자리에 추가로 모든 원소가 0을 갖도록 만들어 주는 것이다. 패딩을 함으로써 모든 matrix의 모든 요소에 대해 convolution을 수행할 수 있게 된다. 그리고 그 뿐만 아니라 input에 비해 좀 더 크거나 동일한 크기의 output을 갖게 된다. 즉 zero padding을 더한 것을 wide convolution 이라 부르고, 사용하지 않은 것을 narrow convolution 이라 부른다. 두 가지 방법을 1-dimension에 적용시킨 것을 그림으로 나타내면 다음과 같다.

필터의 크기가 input 크기에 비해 상대적으로 큰 경우에 wide convolution을 필요로 한다. 위의 그림에서 narrow convolution(왼쪽)은 output size가 $(7-5)+1=3$이 되고, wide convolution(오른쪽)은 output size가 $(7+2*4-5)+1=11$이 된다. 더 일반적으로 공식으로 본다면 output 크기는 다음과 같다.

$n_{\text{out}}=(n_{\text{in}}+2\times n_{\text{padding}}-n_{\text{filter}})+1$

Stride Size

padding이외에 또 다른 hyperparameter는 stride size이다. 각 단게에서 필터가 얼만큼 움직여서 convolution을 수행할 지 결정하는 것이다. 위의 모든 그림은 stride가 1로 설정했을 때이고 이 경우에 convolution되는 부분이 겹쳐진다. 만약 stride를 크게 잡는다면 필터가 더 적게 사용될 것이고 output size도 작아질 것이다. 다음의 그림은 cs231의 stride 크기가 1과 2인 예제이다.

보통의 경우 stride는 1로 설정하지만 더 큰 stride사용한다면 Recursive Neural Network와 비슷한 효과를 만든다. 즉 tree구조가 되는 것이다.

Pooling Layers

CNN의 핵심은 pooling layer이다. 주로 convolution layer 다음에 적용된다. pooling layer는 input 값을 subsample하는 것과 같다. 보통 일반적으로는 max pooling을 사용한다. Pooling은 전체 matrix에 대해서 적용할 필요없이 window 크기를 정하고 해당 window에 대해서 pooling을 진행하면 된다. 아래 그림은 2x2 window로 max pooling을 하는 것을 보여준다.

그렇다면 풀링은 왜하는 것일까? 두가지 정도의 이유가 있다. 첫 번째 이유는 보통 분류 문제에서 고정된 크기의 output을 만들기 위해서 사용한다. 예를 들면 1000개의 filter를 사용해서 풀링을 하면 input 값에 관계없이 1000-dimension의 output을 만들 수 있다. 이러한 특성은 NLP에서 매우 중요하자 우리가 input으로 길이가 각각 다른 문장을 넣을 수 있게 된 것이다. 언어의 특성상 문장의 길이는 대부분 항상 다른데 풀링을 사용함으로써 고정된 output dimension을 가질 수 있는 것이다.

그리고 두 번째로는 풀링은 크기(dimension)을 줄이지만, 중요한 정보는 모두 보존하기 때문이다. 각 필터에서 특정 특징들을 잘 추출한다. 예를들면 부정적인 내용인 “not amazing” 같은 것들이다. 만약 이 문구가 문장 어딘가에 등장했다면 필터를 적용하면 이 문구에 대한 수치가 높기 때문에 풀링 결과 그 수치가 나올 것이다. 따라서 풀링을 진행하면 각 필터에서 핵심적인 정보는모두 보존하는 것이다.

이미지 인식에서 풀링은 기본적인 움직임이나 회전에 대해 불변성을 제공한다. 한 부분에서 풀리을 할 때 output은 이미지를 적은 pixel로 회전하거나 이동시키더라도 거의 동일하다. 비슷한 지역에서 max값은 크게 변하지 않기 떄문이다.

Channels

마지막으로 필요한 것은 Channel에 대한 개념이다. Channel은 input이 어떤 것이냐에 따라 개념이 매우 달라진다. 예를들어 컬러 이미지를 input으로 한다면 Channel은 RGB 3개의 값을 각각 하나의 channel로 가질 것이다. NLP에서도 다양한 Channel을 생각할 수 있다. 예를 들면 word2vec으로 임베딩한 벡터들이 모인 matrix를 하나의 채널로 glove로 임베딩한 벡터들이 모인 matrix를 또 하나의 채널로 사용할 수도 있다. 또 다른 방법으로는 같은 문장에 대해 각 channel은 서로 다른 언어를 나타내는 방법도 있다.

NLP 적용하는 Convolutional Neural Network

이제 CNN의 자연어 처리 분야에서의 활용을 알아보자. 여러 연구 결과들에 대해서 요약해서 알아보도록 한다. 모든 흥미로운 연구들을 볼 수는 없지만, 최대한 유명한 연구들을 살펴 볼 것이다.

CNN이 가장 적합한 분야는 당연히 분류 문제일 것이다. 예를들면 감정 분석, 스팸 탐지, 주제 분류 등이 있을 것이다. Convolution 과 Pooling은 단어들의 순서에 관한 정보를 보존하지 않을 것이고, 따라서 순서가 중요한 PoS Tagging이나 Entitiy Extraction은 CNN을 통해 해결하기 어려울 것이다.(불가능은 아니다. 지역 특징을 input에 추가하면 가능하다.)

Convolutional Neural Networks for Sentence Classification(Kim Y,2014)은 CNN을 다양한 분류 dataset에 적용했다. 주로 감정 분석과 주제 분류문제이다. CNN architecture는 dataset마다 매우 좋은 성능을 보여줬다. 놀랍게도 논문에 사용된 network는 매우 간단하고 효과가 좋다. input값은 word2vec으로 임베딩된 단어들을 concat시킨 문장이다. 이후에 여러개의 filter로 convolution layer를 통과시킨 후 max-pooling layer를 통과시킨다. 마지막으로는 softmax함수를 사용해 분류를 했다. 그리고 이 논문을 보면 두개의 다른 채널을 사용해 실험했다. 하나의 채널은 정적인 단어 임베딩을 사용했고 나머지 하나는 동적인 단어 임베딩을 사용헀다. 이 네트워크는 기존의 CNN 네트워크 (Kalchbrenner, Wang)과 비슷한 구조를 사용했지만 몇가지 layer를 좀 더 추가했다. 추가한 layer는 “semantic clustering”을 하기 위한 layer이다. 아래는 이 논문의 architecture를 보여준다.

Effective use of Word Order for Text Categorization with Convolutional Neural Network(Johnson R & Zhang T, 2015)에서는 word2vec이나 Glove와 같은 걸로 임베딩시키지 않고 학습을 시킨다. one-hot vector를 바로 convolution하는 것이다. 저자는 space efficient bag of words like representation을 제안했다. 이는 학습해야 할 파라미터 수를 줄여준다.

그리고 Semi-supervised Convolutional Neural Networks for Text Categorization via Region Embedding(Johnson R & Zhang T, 2015)에서는 모델을 더욱 확장시켜서 text region의 context를 예측하는 CNN을 학습시키위해 unsupervised “region embedding”을 추가했다. 이러한 접근은 긴 글에서(ex.영화 리뷰) 더욱 잘 동작한다. 그러나 짧은 문장에서는(ex. tweets)에서는 좋은 성능을 보장하지는 않는다. 직관적으로 짧은 문장에서 미리 학습된 단어 임베딩을 사용하는 것이 긴 문장에서 사용하는 것 보다 더 많은 효율을 얻을 수 있다.

CNN 구조를 만드는 것은 위에서 소개된 것들처럼 많은 hyperparameter를 선택해야 한다. 선택해야 하는 것들은 다음과 같다.

Input representation (word2vec, Glove, one-hot)
필터의 크기
풀링 전략(max, average)
활성화 함수(ReLU, tanh)

A Sensitivity Analysis of Convolutional Neural Netwroks for Sentence Classification(Zhang Y & Wallace B, 2015)에서는 CNN architecture에 사용되는 위와 같은 hyperparameter들 각각의 영향에 대해 실증적인 평가를 했다. text classification을 위한 CNN architecture를 직접 만들 계획을 하고 있다면 이 논문을 참고하면서 만드는 것을 추천한다. 몇 가지 나온 결과로는 max-pooling이 항상 average-pooling보다 좋은 성능을 보였고, 필터 크기는 중요하지만 어떤 작업이냐에 따라 다르다는 점이다. 그리고 정규화(regularization)는 NLP 문제에서는 크게 중요하지 않다는 것을 알 수 있다. 하지만 이런 논문 결과를 참고할 때 데이터의 구성이나 크기에 따라 많은 차이가 있을 수 있으므로 데이터가 어떤 구조인지 잘 살펴보고 참고해야 한다.

Relation Extraction: Perspective from Convolutional Neural Networks. Workshop on Vector Modeling for NLP(Nguyen T.H & Grishman R, 2015)에서는 관계 추출과 관계 분류 문제에 대해 연구했다. 저자는 우리가 관심있는 개체에 대한 상대적인 단어의 위치를 convolutional layer의 input값으로 사용했다. 이러한 모델은 각 개체의 위치가 주어졌다고 가정하고 각각의 input은 하나의 관계를 포함한다고 가정한다. Sun Y et al과 Zeng D도 비슷한 모델을 연구했다.

또 다른 NLP에서의 CNN활용한 것들 중 흥미로운 것은 Microsoft Research의 Modeling Interestingness with Deep Neural Network(Gao J et al, 2014)와 A Latent Semantic Model with COnvolutional-Pooling Structure for Information Retrieval(Sehn Y et al, 2014)이다. 이 논문들에서는 어떻게 정보 추출에서 사용될 수 있게 문장의 의미를 잘 표현할 수 있는 지를 소개한다. 주어진 예제는 사용자가 읽고있는 문서를 기반으로 잠재적으로 의미있는 문서를 추천하는 것이다. 문장 표현은 검색엔진의 log 데이터를 기반으로 학습되었다.

대부분의 CNN architecture들은 단어와 문장을 임베딩한다. 하지만 모든 논문이 이러한 부분의 학습에 집중하는 것은 아니다. Semantic Embeddings from Hashtags(Weston J & Adams K, 2014) 에서는 단어와 문장의 의미있는 임베딩을 만들어 내면서 Facebook의 해시태그를 예측하는 CNN architecture를 소개한다. 그들은 성공적으로 임베딩을 했으며 이 값으로 사용자 클릭 데이터를 기반으로한 문서 추천에 적용했다.

Character-Level CNNs

이때까지는 각 단어를 단위로 했다. 이제는 단어를 단위로 하는 것이 아니라 각 문자들을 바로 CNN에 사용하는 모델들을 알아보자.

Learning Character-level Representations for Part-of-Speech Tagging(Santos C & Zadrozny B, 2014)에서는 문자 단위의 임베딩을 학습했다. 그리고 학습한 문자 단위의 임베딩값을 미리 학습된 단어 임베딩을 결합해서 Speech tagging문제를 위한 CNN 구조에 사용했다.

Character-level Convolutional Networks for Text Classification(Zhang X & Zhao J, 2015)와 Text Understanding from Scratch(Zhang X & LeCun Y, 2015)에서는 어떠한 사전 학습된 임베딩값도 사용하지 않고 문자 단위로 바로 CNN에 학습시켰다. 여기서 주목할만한 점은 논문의 저자가 상대적으로 깊은 network를 사용했다는 점이다. 총 9층의 network를 사용해서 감정 분석과 Text Categorization 문제에 활용했다. 문자 단위를 바로 학습시킨 결과는 매우 큰 데이터셋(수 백만~)에서 잘 동작했다. 그러나 상대적으로 적은 데이터셋(수백~수천)에서는 좋은 결과를 보이지 못했다.

Character-Aware Neural Language Models(Kim Y et al, 2015)에서는 문자 단위의 CNN의 output값을 LSTM의 각 time step의 input으로 활용한 모델을 연구했다. 이 모델은 다양한 언어에 적용되었다.

여기까지가 CNN의 NLP문제에서의 활용에 대한 간략한 소개였다. 놀라운점은 위에 소개된 논문들이 불과 지난 2~3년밖에 안된 논문들이라는 점이다. 분명히 이전에서 NLP에서의 CNN의 활용이 있었지만 새로운 결과와 발표되는 최고수준의 시스템들은 계속해서 과속화되고 있다.

TF-IDF : Term Frequency-Inverse Document Frequency

2018-08-01T04:47:35+00:00

정보 검색분야에서 자주 사용되는 TF-IDF에 대해서 소개하려 한다. 뉴스 기사에서 키워드 추천을 위한 수치로도 많이 사용되는 이 값은 NLP분야에서도 다른 기법과 함께 사용되며 score를 올려주는 부가적인 기법으로 자주 사용된다.

TF-IDF는 Term frequency - Inverse document frequency의 약자로 특정 단어에 대해서 단어가 얼마나 자주 등장하는지, 그리고 다른 문서에 대비해서 이 문서에 많이 등장하는 단어인지를 측정하는 수치로 이해할 수 있다.

용어를 보면 알 수 있듯이 TF-IDF는 TF라는 수치와 IDF라는 수치 두가지를 사용했다. 우선 TF, Term Frequency에 대해서 알아본다.

Term Frequency

Term Frequency는 문장 docunment($d$)안에서 특정 term($t$)이 몇 번 등장했는지를 나타낸다. 예를 들어 뉴스 기사에서 ‘인공지능’이라는 단어가 총 4번 등장 했다면 이 documnet의 TF값은 4가 되는 것이다. 위 수치는 다음과 같이 표기된다.

$tf(t,d) = f_{t,d}$

여기서 $f_{f,d}$값은 위에서 말한 문서안에서 term이 나온 횟수자체이다. 하지만 경우에 따라서 tf값을 나온 수치 그대로 사용하는 것이 아니라 변형해서 사용하기도 한다. tf 값을 정의하는 여러 방법들은 아래와 같다.

binary 값(Boolean), 문서 안에 나왔다면 1, 아니면 0

$tf(t,d) = \begin{cases} 1, \text{ if t occur in d}\\ 0, \text{ otherwise} \end{cases}$

나온 횟수

$tf(t,d) = f_{t,d}$

문서안의 전체 term들의 $f$ 값들의 합으로 나눈 값, 전체 문장 길이를 반영한다. 단순히 나온 횟수만 보게 된다면 매우 긴 문장에서 4번 나온 수치와 짧은 문장에서 4번 나온 수치를 같은 값으로 보게 된다.

$tf(t,d) = \frac{f_{t,d}}{\sum_{t'\in d}f_{t',d}}$

나온 횟수를 log scale로 바꾼 값, 많이 등장한 것에 대해서 가중치를 줄이는 방법.

$log(1+f_{t,d})$

증가된 수치, 긴 문서에서 편향되는 것을 막는 방법

$tf(d,f) = 0.5+0.5\frac{f_{t,d}}{max\{f_{t',d},t'\in d\}}$

TF에 대해서 알아보았다. 이제는 IDF를 소개한다. IDF는 Inverse Document Frequency의 약자로 Document Frequency값을 역수로 만든 값을 의미한다. 그렇다면 DF에 대해서 먼저 알아보도록하자.

Document Frequency

DF는 한 문서만 고려하는 값이 아니다. 여러개의 문서가 있을 때 어떤 특정한 단어(term)이 얼마나 많은 문서에 등장하는지 확인 할 수 있는 값이 된다. 계산은 다음과 같이 한다.

$df(t,D) = \frac{|\{d\in D:t\in d\}|}{|D|}$

수식에 대해 설명하면, 우선 $D$와 $d$의 차이는 $d$는 개별 문서를 뜻하며 $D$는 전체 문서 집합을 의미한다. 따라서 $df$값은 특정 단어 $t$가 들어가 있는 문서 수를 전체 문서 수로 나눠준 값을 의미한다. $idf(t,D)$ 값은 단순히 이 값을 역수로 만든 값이다. 대체 왜 역수를 취한 값을 사용하는 것일까? 이 $idf$값의 의미는 어떤 문서에 등장한 특정 단어가 다른 문서들에서는 잘 나오지 않은 단어인지 측정하는 척도이다.

만약 어떤 단어가 다른 문서에는 많이 들어가 있지 않는데 현재 문서에 들어가 있다면 $idf$값은 높게 나올 것이다.

TF-IDF

그렇다면 tf-idf의 의미는 다음과 같을 것이다. 현재 해당 문서에서 특정 단어가 나온 횟수값과 그리고 이 단어가 다른 문서에는 잘 나오지 않는 그런 단어인지를 같이 고려하는 것이다. 이 값의 계산은 다음과 같이 두 값을 곱해주기만 하면 된다.

$tfidf(t,d,D) = tf(t,d)\times idf(t,D)$

마지막으로 이 값을 보는 이유에 대해서 설명을 하자면 각 단어에 대해 중요도를 보는 것이다. 얼마나 자주 등장한 단어인지, 그리고 그 단어가 다른 문서들에는 자주 나오지 않고 해당 문서에서 중요도가 높은 단어인지를 알 수 있다.

Glove : Global Vectors for Word Representation

2018-07-27T04:47:35+00:00

지난 포스트에서는 단어 임베딩 기술인 Word2Vec에 대해서 알아보았다. 이번에는 또 다른 단어 임베딩 기술 중 하나인 Glove에 대해서 알아 보도록한다. 이번 포스트는 요약이 아닌 논문의 흐름을 따라 설명한다. (Paper)

Glove

GLove란 Global Vectors for Word Represnetation의 약자로 미국의 Stanford대학에서 2014년 개발한 기술로 Word2Vec과 마찬가지로 단어 임베딩 과정에서 많이 쓰이는 기법이다.

Glove에 대한 설명을 하기 전 기존의 단어 임베딩 기술에 대해서 먼저 보자. 기존의 단어 임베딩의 경우 크게 두 가지 범주로 나눌 수 있다.

Matrix Factorization Method
Shallow Window-Based Method

두가지 분류에 대해서 하나씩 알아보자. 먼저 Matrix Factorization Method는 LSA, HAL와 같은 것들이 있다.

LSA 에 대해서 간단히 설명을 하자면 전체 문장에서 단어들의 동시 등장정보(공기정보, Co-occurrence)를 이용한다. 전체 문장에 있는 모든 단어에 대해 동시등장정보들을 matrix로 만들어 준다. 하지만 여기에 큰 문제점이 있다. matrix의 크기가 매우 크고 sparse하다는 문제점인데 이를 해결하기 위한 기법이 SVD(Singular Value Decomposition)이다. 이 기법을 이용해 matrix의 차원을 줄이고 dense하게 만들어준다. 이러한 내용이 LSA의 전체적인 내용이다. 자세한 내용을 설명하기엔 전체적인 맥락에 벗어나므로 다음 기회에 설명하도록 한다.

이러한 Matrix Factorization Method는 global한 statical information을 잘 잡아내고 학습이 빠르다는 큰 장점은 있지만 단어 유사도 외의 문제에는 적용하기 어렵고 새로운 단어에 추가시키려면 처음부터 다시 해야한다는 단점이 있다.

그리고Shallow Window-Based Method의 경우는 이전 포스트에서 알아봤던 Word2Vec의 CBOW모델과 Skip-Gram 모델, 그리고 NNLM, HLBL등의 모델들은 뜻한다. Word2Vec에 대한 자세한 설명은 이전 포스트를 참고하자(Word2Vec(1), Word2Vec(2))

Shallow Window-Based Method은 우선 성능이 매우 좋다는 것이 가장 큰 장점이다. 그리고 복잡한 패턴을 dense한 vector로 만들면서 잘잡아낸다는 장점이 있지만, 통계적인 자료를 활용하는데 비효율적이다라는 단점이 있다. 위 내용들을 요약하면 다음과 같다.

Counte based	Shallow Window-Based Method
LSA, HAL	NNLM, SkipGram, CBOW
학습이 빠르다, 전체의 통계정보를 활용한다.	성능이 좋다, 패턴을 잘 잡아낸다.
단어 유사도 외의 문제에 적용이 어렵다.	전체적인 통계정보를 활용하기 어렵다.

Glove는 자신의 모델을 설명할 때 위와 같은 기존의 단어 임베딩 기술들에 대한 문제점들을 해결하려 했다고 합니다. 대표적으로 Word2Vec과 LSA에 대한 단점들에 대해 얘기합니다. 해당 글을 소개하면 다음과 같습니다.

While methods like LSA efficiently leverage statistical information, they do relatively poorly on the word analogy task, indicating a sub-optimal vector space structure. Methods like skip-gram may do better on the analogy ask, but they poorly utilize the statistics of the corpus since they train on separate local context windows instead of on global co-occurrence counts.

즉 이전에 설명한 것과 같은 내용입니다. LSA의 경우 단어 분석 문제에는 적합하지 않고, Skip-gram과 같은 방법의 경우는 분석에는 적합하지만 global한 co-occurrence(동시등장) 정보와 같은 통계치를 활용하기에는 적합하지 않다는 것입니다.

따라서 Glove는 이러한 문제점들을 해결하는데 초점을 맞췄습니다. 먼저 동시 등장 정보를 활용하기 위해 Co-occurrence Matrix를 정의합니다.

Co-occurrence Matrix

Co-occurrence Matrix는 $X$라 부르고 행렬의 원소 $X_{ij}$는 단어 $i$의 context안에서 단어$j$가 등장한 횟수로 정의한다.

그리고 $X_i$는 단어 $i$의 context안에 등장한 단어들의 총 수라 하자. 수식은 다음과 같다.

$X_i=\sum_k X_{ik}$

이러한 행렬의 계산은 말뭉치가 커질 수록 계산량이 급증한다. 예를들어 10,000개의 말뭉치가 있다면 행렬은 총 1억개의 원소를 가지게 된다. 하지만 이 Matrix의 경우 여러번 계산하는 것이 아니라 모델 초반에 한번만 계산하면 된다는 점이 있다.

Objective function

확률 $P_{ij}$은 단어 $i$의 context안에서 단어 $j$가 등장할 확률이라 하고 다음과 같이 정의한다.

$P_{ij}=P(j|i)=\frac{X_{ij}}{X_j}$

정의한 확률에 대한 직관적인 이해를 위해 간단한 예를 들어 보자. 두 개의 별개의 단어를 정의하자. 단어 i를 ‘ice’ 라고하고 단어 j를 ‘steam’ 이라고 하자.

이제 두 단어 사이의 관계에 대해서 알아보려고 한다. 이 경우 우리는 다른 여러가지 단어 $k$ 들에 대한 동시 등장 확률(Co-occurrence Plobability, 위에서 정의한 $P$)의 비율을 확인하면 될 것이다.

먼저 ice에서는 관련되었지만 steam에는 관련없는 단어를 단어 $k$에 지정하자. 단어 $k$를 ‘solid’라고 한다. 이 경우 확률들의 비율인 $\frac{P_{ik}}{P_{jk}}$는 커질 것이다. 그리고 이번에는 ice에 관련 없고 steam에 관련있는 단어인 ‘gas’를 단어 $k$로 정하자. 이 경우 확률의 비율은 작아질 것이다. 만약 두 단어 모두에 연관있는 ‘water’의 경우나 두 단어 모두에 연관이 없는 ‘fashion’의 경우에는 비율이 1에 가깝게 결정될 것이다. 이 결과를 통해 우리는 연관없는 단어를 구분하는 것이 쉽다는 것을 알 수 있다. 따라서 우리는 두 단어에 대한 직접적인 확률이 아니라, 다른 단어에 대한 각각의 확률에 대한 수식을 새우는 것을 목표로한다. 먼저 일반화된 모델을 제시한다.

$F(w_i,w_j,\tilde{w}_k)=\frac{P_{ik}}{P_{jk}}$

여기서 $w\in\mathbb{R}^d$는 단어 벡터이고 $\tilde{w}\in\mathbb{R}^d$는 separate context 단어 벡터이다.

위 수식 중 $F$는 확률에 대한 비율을 정보를 포함해야할 것이다. 그리고 그 정보는 단어 벡터 공간안의 정보여야할 것이므로 두 비율은 벡터들의 차이로 해석할 수 있을 것이다. 따라서 수식을 다음과 같이 수정한다.

$F(w_i-w_j,\tilde{w}_k)=\frac{P_{ik}}{P_{jk}}$

아직까지 정의한 식에서 애매한 부분이 있다. 함수의 인자가 되는 값들은 vector인데 수식의 우변에 있는 값들은 scalar값이다. 따라서 좌변의 인자값을 내적하는 것으로 수정한다.

$F((w_i-w_j)^T\tilde{w}_k)=\frac{P_{ik}}{P_{jk}}$

이제 동시 등장 행렬에 대해 중요한 것은 단어 $j$와 context 단어인 단어 $i$는 무작위로 선택되는 것이기 때문에 이 둘의 역활을 자유롭게 바꿀 수 있어야 한다. 따라서 아래의 조건을 만족해야 한다.

$w\leftrightarrow\tilde{w}$

이렇게 되면 행렬 $X$는 symetric 해야한다. 즉,

$X\leftrightarrow X^T$

최종적으로 마지막 모델은 각 단어에 라벨링하는 것에 따라 변하지 않아야 한다. 그러나 아직 위의 $F$함수는 그렇지 않기 떄문에 두 가지 조건을 만족하도록 해야한다. 첫 째로는 Homomorphism 조건이다. 즉, $F$가 Homomorphism해야 한다.

$\text{Homomorphism} ~F : (\mathbb{R},+)\rightarrow(\mathbb{R_{>0}},\times)$

위 조건을 만족시킨다면 함수 $F$는 다음의 수식을 만족시킨다.

$F((w_i-w_j)^T\tilde{w}_k)=\frac{F(w_i^T\tilde{w}_k)}{F(w_j^T\tilde{w}_k)}$

우변의 각 $F$는 원래 식과 같으므로 다음을 만족한다.

$F(w_i^T\tilde{w}_k)=P_{ik}=\frac{X_{ik}}{X_i}$

이제 함수 $F$를 정해야 한다. 위의 Homomorphism 조건을 만족시키는 함수들 중 exponential함수를 이용하면 된다. 따라서 $F=exp$로 정의한다. 이 경우 아래 수식을 만족할 것이다.

$\begin{align*} &F(w_i^T\tilde{w}_k)=P_{ik}\\ &\Leftrightarrow exp(w_i^T\tilde{w}_k)=P_{ik}\\ &\Leftrightarrow w_i^T\tilde{w}_k=\log(P_{ik})=\log(X_{ik})-\log(X_i) \end{align*}$

하지만 위의 마지막 수식을 보자 아직 $\log(X_i)$ 때문에 수식이 symmetric하지 않다. 하지만 위 식은 $k$에 대해 independent하기 떄문에 bias를 각각 더함으로써 이 문제를 해결할 수 있다.

$w_i^T\tilde{w}_k+b_i+\tilde{b}_k=\log(X_{ik})$

따라서 우리는 위의 식을 만족하도록 모델을 만들 것이다. 따라서 목적함수는 Least sqares regression 함수로한다.

$J=\sum_{i,j=1}^V(w_i^T\tilde{w}_j+b_i+\tilde{b}_j-\log{X_{ij}})^2$

아직 이 수식에는 큰 문제점이 있다. $X$ 행렬은 sparse한 매트릭스인데 log함수를 넣으면 행렬값이 0 이될경우 발산하기 때문에 계산이 불가능해진다. 따라서 행렬 $X$에 대해서 모든 원소에 1을 더해주면 이 문제는 해결할 수 있다. 하지만 이러한 해결방법은 또 다른 문제를 야기한다. 행렬 $X$의 경우 매우 sparse해서 보통 원래 원소값이 0인 경우가 75~95%정도 되는데 우리가 모든 원소에 1을 더함으로써 거의 안나오는 경우와 한번도 안나오는 경우를 같은 동시 등장 값을 가진다. 따라서 우리는 Weighting 함수를 추가한 목적함수를 만든다 Weighting 함수 $f$는 다음의 특징을 가지며, 수식은 아래와 같이 정의한다.

$f(0)=0$ 이다. 행렬 $X_{ij}$값이 0이더라도 발산하지 않게끔 하기 위함이다.
$f(x)$는 non-decreasing 해야한다. 드물게 등장하는 경우에 overweighted 되지 않게 하기 위함이다.
$f(x)$는 $x$값이 클 경우 상대적으로 작은 값을 가져야 한다. 자주 등장하는 단어가 overweighted 되지 않도록 한다.

$f(x) = \begin{cases} (x/x_{\text{max}})^\alpha~~,\text{if}~x<x_{\text{max}}\\ 1,~~otherwise \end{cases}$

$x_{\text{max}}$와 \alpha값은 직접 지정해줘야 하는 hyperparameter이다. 논문에 따르면 $\alpha=3/4$와 $x_{\text{max}}=100$이 가장 좋은 결과를 만들었다고 한다.

이제 마지막으로 weighted least squares 함수를 정의하자.

$J=\sum_{i,j=1}^Vf(X_{ij})(w_i^T\tilde{w}_j+b_i+\tilde{b}_j-\log{X_{ij}})^2$

위의 목적함수를 학습시킨 후 나온 $w$벡터를 임베딩 벡터로 사용한다.

마지막으로 논문에서 여러 임베딩 기법들을 비교한 자료를 보며 포스트를 마치도록 한다.

Word2Vec (2) : Skip Gram 모델 & 튜닝 기법

2018-07-24T04:47:35+00:00

Word Embedding & Word2Vec(CBOW model) (이전 포스트)
Word2Vec(Skip-Gram) & 튜닝 기법

Skip-Gram

이제는 Word2Vec의 두 번째 모델인 Skip-Gram 모델에 대해서 알아보도록 한다. CBOW와 비슷한 아이디어지만 반대의 개념이다. CBOW는 주변 단어들을 통해서 중간의 단어를 예측하는 모델이였다면 Skip-Gram은 중심 단어를 통해 주변단어를 예측하는 모델이다. 아래 예시를 보자.

__ __ __ 배가 __ __ __ __

위의 예시와 같이 중간의 단어를 통해 주변단어를 예측하는 모델이다. 아키텍쳐 또한 CBOW와 반대라고 생각하면 된다. 아래 그림을 보자.

Skip-Gram 모델이 진행되는 과정에 대해서 알아보자.

가운데 단어를 one-hot vector로 만들어 준다.

$x\in\mathbb{R}^{|V|}$

다음으로 파라미터 매트릭스인 $\mathbf{W}_{V\times N}$를 중간 단어 one-hot vector에 곱해줘서 embedded vector를 구한다.

$v_c=\mathbf{W}x\in\mathbb{R}^n$

embedded vector를 두 번째 파라미터 매트릭스인 $\mathbf{W^{\prime}}$를 곱해서 score vector를 계산한다.

$z=\mathbf{W}^{\prime}v_c$

이제 위에서 구한 각 score vector에 대해서 확률값으로 만들어 준다.

$\hat{y}=\text{softmax}(z)$

Skip-Gram의 모델의 경우 context의 주변 단어 모두를 예측하기 때문에 확률 값이 다음과 같이 $2m$개 나올것이다.

$\hat{y}_{c-m}, ..., \hat{y}_{c-1},\hat{y}_{c+1},...,\hat{y}_{c+m}$

이제 구한 확률값에 대해서 각 위치의 정답과 비교한다.

$y^{(c-m)},...,y^{(c-1)},y^{(c+1)},...,y^{(c+m)}$

이제 학습을 위해 Objective function은 다음과 같이 정의하고 최소화 할 것이다. 여기서 중요한 CBOW와의 차이점은 우리가 각 단어에 대해 독립이라고 가정을 한다는 것이다. 즉 중심 단어에 대해 주변 단어들을 완벽하게 독립적이라고 가정하는 것이다.

$\begin{align*} \text{minimize}~J&=-\log P(w_{c-m},...,w_{c-1},w_{c+1},...,w_{c+m}|w_c)\\ &=-\log \prod^{2m}_{j=0,j\ne m} P(w_{c-m+j}|w_c)\\ &=-\log \prod^{2m}_{j=0,j\ne m}\frac{\exp(u^{\intercal}_{c-m+j}v_c)}{\sum_{k=1}^{|V|}\exp(u_k^{\intercal}v_c)}\\ &=-\sum^{2m}_{j=0, j\ne m}u^{\intercal}_{c-m+j}v_c+2m\log\sum^{|V|}_{k=1}\exp(u_k^{\intercal}v_c) \end{align*}$

CBOW 모델과 같이 확률값을 cross-entropy함수로 정의된다.

$\begin{align*} J&=-\sum^{2m}_{j=0,j\ne m}\log P(u_{c-m+j}|v_c)\\ &=\sum^{2m}_{j=0,j\ne m}H(\hat{y},y_{c-m+j}) \end{align*}$

여기서 $H()$가 cross entropy가 된다. 여기까지가 Skip-Gram에 대한 소개다. 하지만 이번 포스트에서는 skip-gram을 좀 더 빠르고 효율적으로 만드는 세가지 기법에 대해서 소개한다.

Subsampling Frequent words

Skip-Gram모델은 중심 단어에 대해서 주변 단어를 예측하며 Update하기 때문에 CBOW모델보다 각 단어에 대해서 update 기회가 더 많다(SkipGram모델을 CBOW보다 많이 쓰는 이유이기도 하다.). 아래 그림을 보면 Skip-Gram이 학습을 진행하는 과정에 대해서 볼 수 있다.

학습 과정을 보면 단어 “the”와 다른 단어들이 같이 trainning되는 경우가 많다는 것을 볼 수 있다. 이 그림은 하나의 Sentence에 대해서 본 것이지만 실제 학습은 전체 Data에 대해서 진행 할 것이다. Data안에서 “the” 라는 단어와 함께 update 되는 것들이 얼마나 많을지 생각해보자. 단어의 특성상 Data안에서 매우 자주 등장할 것이고 그 만큼 update되는 횟수도 많은 것이다. 하지만 update되는 횟수에 비해 “the”라는 단어가 의미적으로 중요하지도 않다. 이러한 경우 학습시간만 증가시킬뿐 학습 정확도에는 크게 기여하지 않는다. 이런 문제를 해결하는 방법이 Subsampling Frequent words이다.

Subsampling하는 방법은 학습시에 단어들을 무작위로 제외시키는 것이다. 만약 자주 등장하는 단어라면 더 자주 제외시켜야한다. 단어별로 제외되는 확률은 다음과 같이 정의된다.

$P(w_i) = 1- \sqrt{\frac{t}{f(w_i)}}$

위 식에서 $f()$는 각 단어의 전체 Data에서 출현하는 횟수이다. 즉 자주등장하는 단어일수록 확률값을 줄어들게 된다. 그리고 $t$는 HyperParameter값으로 논문의 연구진들은 $t$값으로 $0.00001(10^{-5})$ 값을 추천한다.

Negative Sampling

그리고 Skip-Gram모델의 Objective function을 다시 한번 보자. Summation이 $|V|$번 돌고 있다는 것을 볼 수 있다. $|V|$은 vocabulary의 크기로 단어의 개수는 수만에서 수백만 까지도 될 수 있다는 점을 기억하자. 직관적으로 봐도 이 식을 계산하는 것은 매우 오래걸릴 것 같다. 실제로도 오래걸린다.

그렇다면 학습 과정에서 속도를 올려줄 수 있는 방법은 무었일까? 방법은 정확한 계산을 하지 않고 계산량을 줄인 다음 근사시키는 방법이다. 이러한 방법 중 하나인 Negative Samgpling 방법에 대해서 소개한다.

Negative Sampling의 방법은 다음과 같다. 기존의 확률계산(Softmax 계산)에서는 모든단어에 대해서 전체 경우를 구했지만, 여기서는 현재 Window내에서 등장하지 않는단어를 특정개수만 뽑아서 확률을 계산하는 것이다. 예를들면 Window size가 5라면 window내에 등장하지 않는 Data내의 다른 단어 5~25개 정도의 단어를뽑아서 확률을 계산하는 것이다.

Negative Sampling을 사용하기위해 Objective function을 다시 정의한다.

$J_t(\theta)=\log\sigma(u_o^\intercal v_c)+\sum_{j\sim P(w)}[\log\sigma(-u_j^\intercal v_c)]$

여기서 확률 $P()$는 ‘Unigram Distribution’이며 다음과 같이 정의한다.

$P(w_i)=\frac{f(w_i)^{3/4}}{\sum_{j=0}^n(f(w_j)^{3/4})}$

3/4같은 수는 고정값으로 논문에 따르면 다른 값들에 비해 성능을 가장 잘 내는 값이라고 한다.

Hierarchical Softmax

Hierarchical Softmax는 기존의 계산량이 많은 Softmax함수 대신 사용해서 계산량을 줄이는 방법 중 하나이다. 이름 그대로 Softmax를 전체로 계산하기 보다는 Tree구조로 Hierarchical하게 Softmax를 계산한다. 먼저 그림을 보자.

각 단어에 대해 Softmax를 계산하려면 우선 node값부터 해당 word까지 내려가면서 각 값을 곱하는 방법이다. Hierarchical의 계산과정에 대한 자세한 설명을 생략한다. 자세히 알고 싶다면 이 링크를 통해 확인하자.

Hierarchical Softmax와 Negative Sampling은 확률 값 계산의 계산량을 줄이기 위한 방법으로 목적이 같다. 따라서 택일하여 사용해야한다.

Word2Vec (1) : 단어 임베딩 & CBOW 모델

2018-07-21T04:47:35+00:00

Word2Vec

NLP에 처음 공부하고 부터 계속해서 듣고 사용하는 기술 중 하나는 무엇보다도 Word2Vec이다. 기존의 one-hot vector 방식의 단어 표현은 단어간 유사도를 전혀 표현할 수 없다는 치명적인 단점을 해결하기 위해 Google에서 나온 기술로 단어들의 특정 dimension의 vector로 만들어 주는 word embedding의 대표적인 방법이다.

매번 라이브러리를 사용해 Word2Vec을 사용만해와서 학습과정이나 모델의 세부적인 내용에 대해서는 잘 알지 못했는데 cs224n 강의를 들으면서 이번 기회에 정리를 해보려한다.

다음의 순서로 Word2Vec을 소개하려한다.

Word Embedding & Word2Vec(CBOW model)
Word2Vec(Skip-Gram) & 튜닝 기법(다음 포스트)

WordEmbedding

컴퓨가 문장을 어떻게 이해할까? 컴퓨터의 경우 문자를 유니코드의 집합으로 읽을 것이다. 따라서 컴퓨터가 문장의 뜻이나 문장간의 유사도등을 이해하기는 불가능에 가까울 것이다. 그래서 컴퓨터에게 문장을 학습시키위해 단어를 수치화시키는 것이 첫 목표였다. 가장 기존의 방식은 다음과 같다. 다음과 같은 단어가 있다고 하자.

$\text{I watch the movie yesterday}$

그리고 우리는 여러 단어를 포함하는 다음과 같은 사전을 가지고 있다.

$\begin{align*} &\text{0 : watch}\\ &\text{1 : I}\\ &\text{2 : the}\\ &\text{4 : yesterday}\\ &\text{5 : movie} \end{align*}$

그렇다면 위의 문장은 다음의 벡터들의 집합으로 표현할 수 있다.

$\begin{align*} &[0,1,0,0,0] \text{ = I}\\ &[1,0,0,0,0] \text{ = watch}\\ &[0,0,1,0,0] \text{ = the}\\ &[0,0,0,0,1] \text{ = yesterday}\\ &[0,0,0,1,0] \text{ = movie}\\ \end{align*}$

이런 방법을 one-hot encoding 방법이라 부른다. 벡터의 하나의 원소만 ‘1’이고 나머지는 모두 ‘0’인 벡터로 encoding한다는 것이다. 하지만 이러한 방법들은 단어를 수치화하는데는 성공했지만 치명적인 단점이 있다.

단어간 유사도를 나타낼 수 없다.(어느 두벡터를 내적해서 0이나온다)
문장 데이터가 많아질수록 사전벡터의 크기가 너무 커져 모델이 느려지고 비효율적이다.
벡터가 너무 크고 sparse하다.

이러한 문제를 해결하기 위해 단어를 유의미한 수치를 가지는 벡터로 만들기 위한 방법을 연구했다. 이러한 방법을 Word Embedding이라 부른다. 따라서 단어는 각 벡터로 표현되고 이 벡터는 단어들간 유사도 또한 나타내는 것이다.

이러한 방법은 2003년부터 제기된 방법부터 여러가지가 있지만 최근 가장많이 사용하고 가장 효율이 좋은 Miklov에 의해 만들어진 word2vec에 대해 알아보도록 한다.

Word2Vec

Word2Vec은 2013년 Efficient Estimation of Word Representations in Vector Space에서 처음 나왔으며, 이후 같은 모델이지만 몇 가지 튜닝기법 추가와 약간 수정된 Distributed Representations of Words and Phrases and their Compositionality 이 나왔다.

Word2Vec의 가장 중요한 아이디어는 언어학의 Distributional Hypothesis이다. 즉 ‘비슷한 분포를 가진 단어들은 비슷한 의미를 가진다’라는 의미로 좀 더 쉽게 표현하면 같이 등장하는 횟수가 많을 수록 두 단어는 비슷한 의미를 가진다 라는 내용이 핵심 아이디어이다. 모델은 Continuous Bag Of Word(CBOW)와 Skip-Gram모델 두 가지다. 최근에는 CBOW보다는 Skip-Gram을 주로 사용하지만, 여기서는 두 모델 모두 하나씩 알아보도록 하자.

Continuous Bag of Words Model (CBOW)

CBOW의 기본적인 아이디어는 다음과 같다. 주변단어를 통해서 주어진 단어가 무었인지 찾는 것이다. 정확히는 앞뒤로 $\frac c2$개의 단어를 (총c개) 통해 주어진 단어를 예측한다는 것이 CBOW의 아이디어이다. 다음의 문장을 보자

“아침을 안먹었더니 __가 너무 고프다”

위와같은 문장이 있다고 하자. 우리는 주변 단어들을 통해 빈칸에 들어갈 단어를 예측할 수 있다.

CBOW의 아키텍처는 다음의 그림과 같다. CBOW의 학습과정에 대해 알아보자.

우선 학습시킬 문장의 모든 단어들을 one-hot encoding 방식으로 벡터화 한다.

$x_k=[0,...,0,1,0,...,0]$

그리고 하나의 중심단어에 대해 $2m$개의 단어 벡터를 input값으로 갖는다.

$(x^{c-m},x^{c-m+1},...,x^{c-1},x^{c+1},...x^{c+m-1},x^{c+m})\in\mathbb{R}^{|V|}$

파라미터는 Input Layer에서 Hidden Layer로 가는 파라미터 매트릭스와 output layer로 가는 파라미터 매트릭스 이다.

$\mathbf{W}\in\mathbb{R}^{V\times N},~\mathbf{W}^{\prime}\in\mathbb{R}^{N\times V}$

(작성상 편의와 햇갈림을 방지하기 위해 $\mathbf{W}^{\prime}$는 아래의 설명에서는 $\mathbf{U}$작성했다.)

이 모델의 목적은 주변단어들이 주어졌을 떄의 중심 단어의 조건부 확률을 최대화 하는 것이다. 즉 다음의 확률을 최대화 하는 것이다.

$P(x_c|x_{c-m},...x_{c-1},x_{c+1},...,x_{c+m})$

그렇다면 네트워크의 진행 과정에 대해서 알아보자. 각 단어는 one-hot encoding 방식이므로 파라미터 $W$와 곱하면 각 단어를 나타내는 행과 곱해지고 나머지는 0으로 곱해지지 않을 것이다. 아래의 그림을 보면 명확하게 이해될 것이다.

즉 one-hot encoding 방식의 단어벡터들은 파라미터와 곱해져서 embedded word vector가 될 것이다.

$(v_{c-m}=\mathbf{W}x^{c-m},...,v_{c+m}=\mathbf{W}x^{c+m})\in\mathbb{R}^n$

이후 $2m$개의 embedded vector들의 평균을 구한다. 이때 평균해서 구한 벡터가 Hidden Layer값이 된다.

$\hat{v}=\frac{v_{c-m}+v_{c-m+1}+\dotsm+v_{c+m}}{2m}\in\mathbb{R}^n$

이제 output layer로 전달할 값인 score값을 계산해야 한다. 파라미터 $\mathbf{U}$를 곱해서 각 단어에 대한 score를 만든다. 가까운 위치의 단어들은 높은 값을 갖도록 해야 한다.

$z=\mathbf{U}\hat{v}\in\mathbb{R}^{|V|}$

마지막으로 각 score값들을 확률 값으로 계산한다.

$\hat{y}=softmax(z)\in\mathbb{R}^{|V|}$

확률은 softmax를 사용한다. 각 단어에 파라미터 $\mathbf{W}$를 곱하면 단어는 one-hot vector이기 때문에 각 단어에 해당하는 행만 계산될 것이다. 이때 각 단어에 해당하는 행은 단어의 embedding vector($v_k$)가 된다.

네트워크의 진행과정에 대해서 소개했다. 이제 필요한 것은 이 파라미터들을 학습하는 것이다. 학습을 위해 Objective function을 정의해야한다. Objective function은 아래와 같으며 우리는 그 값을 minimize하는 방향으로 학습할 것이다.

$H(\hat{y},y)=-\sum^{|V|}_{j=1}y_j\log(\hat{y_j})$

Objective function은 위와 같다. 모든 원소에 대한 sum을 계산하는 것이지만 $y_j$벡터가 one-hot vector라는 것을 기억하자. 결국 하나의 원소에 대해서만 계산될 것이다. 결국 Objective function은 다음과 같이 간단하게 표현할 수 있다.

$H(\hat{y},y)=-y_i\log(\hat{y}_i)$

여기서 $i$는 우리가 예측하는 단어가 될 것이다. 단어를 정확하게 예측했다면 $H$값은 0이 될 것이다.그리고 우리는 위 식을 다음과 같이 확률 분포에 대한 식으로 볼 수 있다. 따라서 Objective funciton을 다음과 같이 표현한다.

$\begin{align*} minimize J &=-\log P(w_c|w_{c-m},...,w_{c+m})\\ &=-\log P(u_c|v^)\\ &=-\log \frac{exp(u_c^{\intercal}\hat{v})}{\sum^{|V|}_{j=1}exp(u_j^{\intercal}\hat{v})}\\ &=-u_c^{intercal}\hat{v}+\log\sum^{|V|}_{j=1}exp(u_j^{\intercal}\hat{v}) \end{align*}$

optimize 방법으로는 SGD를 사용한다. 마지막으로 CBOW모델의 계산량은 다음과 같다.

$C$개의 단어를 Hidden Layer로 보내는 $C\times N$
Hidden Layer에서 Output Layer로 가는 $N\times V$

즉 전체 계산량은 $C\times N + N\times V$이다.

모든 문장에 대해 학습을 마친후 우리는 $W$ 행렬의 각 행을 각 단어의 embedding vector로 사용하게 된다.

Chapter 4: Recurrent Neural Networks and Gated Recurrent Units

2018-07-18T04:47:35+00:00

Chapter 4 Recurrent Neural Networks and Gated Recurrent Units

이 내용은 Newyork University의 조경현교수님의 NLP_DL강의 lecture note중 Recurrent Neural Networks and Gated Recurrent Units단원을 정리한 내용이다.

이번 단원에는 몇 개의 단원에서 생략된 부분이 있습니다. 전체적인 흐름에 있어선는 문제가 없다고 판단되는 선에서 생략했으나, 혹시나 생략된 부분에 알고 싶으신 분들은 lecture note를 참고해 주시기 바랍니다.

4.1 Recurrent Neural Network

기존의 우리가 배운 Neural Network에서는 input $x$가 고정 size의 scalar 혹은 vector였다. 그러나 여기서는 input $x$가 고정 size라는 가정을 없에고 가변 길이의 input, 즉 sequence를 다루는 법을 알아 볼 것이다.

$x^k=(x_1^k, ..., x^k_{l^k})$

우선 가장 간단한 형태인 binary값을 가지는 sequence에 대해서 살펴보자. 1 혹은 0 만을 가지는 sequence에 대해서 1의 개수를 알고 싶다면 어떻게 해야 할까? 이 때 사용해야 하는 함수는 다음과 같다.

위 알고리즘을 사용한다면 sequence에서의 1값이 몇번인지 확인 할 수 있을 것 이다. ADD1 알고리즘의 중요한 특징은 다음과 같다.

‘1’의 개수를 새는 memory $s$
sequence의 각 symbol에 ‘하나씩’ 적용된다.(차례대로)

이 두가지 특성 때문에 가변길이의 sequence에 사용될 수 있다. 이 ADD1 알고리즘의 idea(‘memory’&’recursive function’)를 일반화 하자. 가장 일반적인 예는 컴퓨터이다. 특히 컴퓨터에서 CPU가 명령어를 처리하는 과정에 위의 idea가 사용되었다. (CPU : sequence of instruction($x_i$)) 그러나 우리가 필요한 것은 학습을 위한 Network이므로 parametric recursive function (NLP를 하기 위한 언어적 symbol을 읽을 수 있는)가 필요하다.

Parametric recursive function을 만들기 위해 필요한 것에 대해 먼저 생각해보자. 우선 memory역할을 할 vector가 필요하다 이를 $h\in\mathbb{R}^{d_h}$라 하자. 그리고 recursive한 fucntion은 input symbol과 memory $h$ 둘 다 input으로 받는다. 이후 function을 통과시켜 memory를 업데이트 시킨 후 return한다. 각각의 memory $h$를 구분하기 위해 time index을 사용한다. ($h_t,h_{t-1},…$) 이러한 recursive한 fucntion은 다음과 같이 작성될 것이다.

$h_t=f(x_t,h_{t-1})$

그리고 함수 $f()$는 다음과 같이 정의한다.

$f(x_t, h_{t-1})=g(W)\phi(x_t)+Uh_{t-1}$

$\phi(~~)$함수는 input symbol을 d dimension으로 바꿔주는 함수.
$W\in\mathbb{R}^{d_h\times d}$
$U\in\mathbb{R}^{d_h\times d_h}$
$g$는 element-wise nonlinear한 activation function뭐든 사용가능 하다.(e.g $tanh, sigmoid$)

위의 함수를 통과하게 되면 $d_h$ dimension을 가지는 vector가 된다. 이 값은 다음 값의 memory로 사용되거나 output으로 사용된다.

함수에 대해서 정의했으므로 이제는 두 가지 분류로 문제를 구분할 것이다.

fixed-size의 output $y$
variable length sequence의 output $y$

4.1.1 Fixed size output

기본적인 binary classification의 경우에 대해서 살펴보자. 가장 대표적인 binary classification의 예는 글에 대해 positive(1), negative(0) 감정을 평가하는 문제다. 이러한 문제는 결과가 0 혹은 1이므로 bernoulli distribution이라 생각할 수 있다. 따라서 우리는 distribution의 유일한 parameter인 $\mu$만 구하면 된다. 따라서 $\mu$를 다음과 같이 정의한다.

$\mu = \sigma(\mathbf{v}^\intercal h_l)$

마지막 memory인 $h_l$사용
활성화 함수로 sigmoid 함수 사용한다.(0~1값을 출력해야 하므로)

따라서 전체적인 계산은 다음과 같이 한다.

$\mu = \sigma(\mathbf{v}^\intercal~g(\mathbf{W}\phi(x_l)+\mathbf{U}g(\mathbf{W}\phi(x_{l-1})+\mathbf{U}g(\mathbf{W}\phi(x_{l-2}))+\dotsm)))$

여기서 가장 최초의 memory인 $h_0$는 보통 all zero vector를 사용한다. 그리고 $\mathbf{W, U}$는 shared parameter다.

또 다른 예를 들어 보자. 이번에도 감정 분석 문제이지만, 이번에는 분석해야 할 class가 3개, 즉 positive(1), neutral(2), neagtive(3)으로 분석해야 하는 문제에 대해 살펴보자. 이번에는 출력값이 $\mu$값 1개가 아닌, 3개의 $\mu$를 가지는 $\mathbf{\mu}= [\mu_1, \mu_2, \mu_3]$벡터를 출력으로 구해야 한다. 구하는 방식은 이전과 거의 비슷하지만 마지막 output을 뽑아낼 때 sigmoid가 아닌 softmax를 사용해야 한다.

$\mu = [\mu_1, \mu_2, \mu_3]^\intercal=softmax(\mathbf{v}h_l)$

4.1.4 Variable length output

가변길이의 output은 sequence형태가 된다.

$y=(y_1,y_2,...,y_l),~~\text{such that}. ~|x_k|=|y_k|$

이러한 문제의 대표적인 예는 POS tagging 문제다. 각 input $x$에 대해 noun, verb, adjective, others에 대한 각각의 확률값을 출력하는 문제다.

$\begin{matrix} x = (\text{children, eat, sweet, candy})\\ y = (\text{noun, verb, adjective, noun}) \end{matrix}$

이러한 경우에는 각각의 step에서 memory를 각 step의 출력층, 다음 step 두 곳 모두로 보낸다. 각각의 layer에서의 출력은 다음과 같이 계산한다.

$\begin{matrix} \mu_t &=& [\mu_{t,1}, \mu_{t,2}, \mu_{t,3},\mu_{t,4}]\\ &=&softmax(\mathbf{V}h_t)~~~~~ \end{matrix}$

학습을 위해 각 step의 Cost는 다음과 같이 정의한다.

$C_{x,t}(\theta)=-\log \sum^k_{k=1}\mathbb{I}_{k=y}\mu_{t,k}$ $\mathbb{I}_{k=y}= \begin{cases} 1, & \text{if}~~k=y \\ 0, & \text{elsewise} \end{cases}$

Cost함수에 대해서 간단히 설명을 하자면 I함수 때문에 정답 label을 가지는 단어에 대해서만 log값을 계산한다. 이 때 -log함수이기 떄문에 1에 가까울수록 적은 Cost를 가지고, 0에 가까울 수록 매우 큰 Cost를 가지게 된다. 따라서 전체적으로 우리는 Cost를 minimize하는 방향으로 가야 한다.

Cost 계산을 실제로 할때는 총합을 계산해서 학습을 시킨다.

$C_{x}(\theta)=-\sum_{t=1}^l\log \sum^k_{k=1}\mathbb{I}_{k=y}\mu_{t,k}$

위의 전체 cost를 minimize하는 방향으로 Network를 학습시켜야 한다.

결국 이 식이 목표하는 것은

$P(y|x) = \sum^l_{t=1}\log P(y_t|x_1, ...,x_t)$

이 조건부 확률을 최대화 하는 것이다. 그러나 위의 식을 단순히 cost함수로 표현을 하기에는 각각의 $x$ value들이 independent하다는 가정이 필요하다. 그러나 대부분의 경우에 그러한 가정을 사용하기에는 무리가 있다. 예를 들어 POS tagging 의 경우에만 봐도 명사 뒤에는 동사가 나올 확률이 높아진다. 이런 경우만 봐도 $x$ value들은 independent라고 하기는 어렵다. 따라서 우리는 condition으로 $y$의 값도 사용함으로써 독립 가정에 의한 격차를 줄인다. 즉, 아래와 같은 식으로 계산한다.

$h_t=f(x_t,y_{t-1},h_{t-1})=g(\mathbf{W}_x\phi_x(x_t)+\mathbf{W}_y\phi_y(y_{t-1}+\mathbf{W}_hh_{t-1}))$

4.2 Gated Recurrent Unit

이때까지의 살펴본 RNN은 CPU가 작동하는 과정과 매우 유사하다고 볼 수 있다. 그러나 유사하다는 것은 concept적인 부분이고 실제 practical한 부분에서는 차이가 있다. 우리가 살펴본 RNN구조에서는 각 step에서 모든 memory가 refresh(update)된다는 점인데, CPU에서는 memory중 사용되는 값과 사용되지 않는 값이 다르게 refresh된다. 이런 CPU의 계산 과정을 mathmatical하게 표현하면 아래와 같이 표현할 수 있다.

$\tilde{h}_t=g(\mathbf{W}\phi(x_t)+\mathbf{U}(\mathbf{r}\odot h_{t-1}))$

여기서 $\odot$은 element-wise multiply를 의미한다. 위 식은 실제 사용되는 메모리가 아니라 candidate memory로 memory값으로 사용 될 수 있는 memory를 의미한다. 실제 메모리의 수식은 다음과 같다.

$h_t=(1-\mathbf{u})\odot h_{t-1}+\mathbf{u}\odot\tilde{h}_t$

수식을 보면 아직 소개하지 않은 값들이 있는데 $\mathbf{r, u}$이다. 이 두값은 다음과 같이 표현될 수 있다.

$\mathbf{u}= \begin{cases} 1, & \text{will not be used} \\ 0, & \text{will be used} \end{cases}$ $\mathbf{r}= \begin{cases} 1, & \text{will change} \\ 0, & \text{does not changed} \end{cases}$

이 식들 중 $\tilde{h}_t$를 구하는 식을 reset gate라 부르고, $h_t$를 구하는 식을 update gate라 부른다.

이제 우리가 알아볼 GRU에 대해서 살펴보자. GRU의 경우에는 위의 CPU가 working하는 과정과 매우 유사하다. 하지만 차이점에 대해서 먼저 생각해보면 우선 GRU의 경우 CPU처럼 instruction들에 대한 정보가 없어서 $\mathbf{u,r}$를 미리 setting 할 수 없다. 그리고 또 큰 차이점이자 문제점이라 할 수 있는 부분은 $\mathbf{u,r}$를 binary하게 0,1 값으로만 준다면 학습 시 미분값이 거의 대부분 0이 되서 학습을 할 수 없다. 따라서 두 벡터를 binary한 값이 아닌, [0,1]의 값을 가지는 real valued vector로 만든다.

$\mathbf{u}\in[0,1]^{n_h},~~\mathbf{r}\in[0,1]^{n_h}$

그리고 다음과 같은 식이 최종적으로 완성된다.

$\begin{matrix} \mathbf{r}_t=\sigma(\mathbf{W}_r\phi(x_t)+\mathbf{U}_rh_{t-1})\\ \mathbf{u}_t=\sigma(\mathbf{W}_u\phi(x_t)+\mathbf{U}_u(\mathbf{r}\odot h_{t-1}))\\ \end{matrix}$

그리고 각 step 에서 update는 다음과 같이 진행됩니다.

$\begin{matrix} \tilde{h}=\tanh(\mathbf{W}x_t+r_t\odot\mathbf{U}h_{t-1})\\ h_t=\mathbf{u}_t\odot h_{t-1}+(1-\mathbf{u}_t)\odot\tilde{h}_t \end{matrix}$

전체적인 구조와 각 계산들에 대해 하나씩 그림으로 보겠습니다. 그림의 출처는 이곳이며 소개한 수식에서 $\mathbf{u}$가 $\mathbf{v}$로 표현됬다는 차이가 있습니다.

전체 구조

Update Gate

Reset Gate

cadidate memory

Final memory

4.2.3 Long Short-Term Memory(LSTM)

위의 GRU는 LSTM을 motive로 만들어진 network이다. LSTM과 GRU의 차이는 LSTM은 memory state $c_t$와 output $h_t$를 분리했다는 점이다. 이 책에는 LSTM에 대한 설명이 많지 않아서 다음 포스트에서 LSTM에 대해 따로 소개하도록 한다.

4.3 Why not Rectifiers?

GRU의 구조를 보면 활성화 함수로 sigmoid와 tanh를 사용했다는 점을 알 수 있다. sigmoid의 경우에는 0~1값을 출력을 위해 사용했다고 이해 할 수 있지만, tanh같은 경우에는 CNN에서 좋은 성능을 보이는 Rectify계열의 활성화 함수(e.g. maxout,ReLU)를 사용하지 않은 이유에 대해 알아보도록 한다.

아래의 식을 보자. 이전에 소개된 식이다.

$f(x_t,\mathbf{h}_{t-1}=g(\mathbf{w}\phi(x_t)+\mathbf{U}\mathbf{h}_{t-1}))$

이 식에서 함수 $g()$는 활성화 함수이다. 이 함수를 다음과 같은 Recifier함수를 사용해 보자.

$g(a)=a$

그리고 마지막 output을 계산하기 위한 값이자 memory인 $h_l$을 계산해보고 그 값의 norm을 계산해보자. 이 계산과정에 대한 다른 설명은 따로 하지 않고 lecture note에 나온 계산 과정만 확인한다.

다음의 식에서 알 수 있는 것은 Rectify계열의 함수는 unbounded 하다는 특성이 있다. 따라서 RNN의 특성상 연쇄적으로 곱해진다면 norm은 기하급수적으로 증가하게 된다. 따라서 마지막 메모리인 $h_l$값이 무한대로 발산하게 된다.

$||h_l||\to\infty$

이러한 문제점들 때문에 unbounded한 함수를 사용하지 않고 bounded된 sigmoid 혹은 unbounded한 함수를 활성화 함수로 사용한다.

4.3.2 Is tanh a Blessing?

이전 section에서 rectify계열의 활성화 함수를 사용하는 것 보다 sigmoid 또는 tanh를 사용해야 한다는 것을 확인했다. 그렇다면 tanh(혹은 sigmoid)의 경우는 항상 좋은 점만 있는지 살펴보자.

일반적으로 RNN을 계산해 output을 계산할 때 까지는 큰 문제점 없이 계산된다. 하지만 학습과정에서 backpropagation을 하면 문제점이 발생한다.

여기서도 note에 소개된 계산 과정에 대해서는 설명하지 않겠다. 어떠한 과정인지만 설명을 하자면 Backpropagation에서 마지막 memory인 $h_l$에 대한 처음 memory인 $h_{l_0}+1$로 미분한 값의 norm을 구하는 과정이다. 아래를 보도록 하자.

이 식에서 의미하는 것은 $\mathbf{U}$의 eigenvalue의 최대값이 $\frac1\lambda$보다 크다면 미분값이 무한대로 갈 것이고, 반대의 경우에는 0으로 수렴한다는 내용이다.

즉 tanh를 사용한 경우 feedforward계산에는 크게 문제가 없지만 backpropagation과정에서 gradient exploding 과 gradient vanishing 이 발생한다는 문제점이 있다.

4.3.3 Are We Doomed?

Exploding Gradient

이전 section에서 gradient가 exploding하는 문제에 대해 확인했다. 그렇다면 이러한 문제를 해결하는 방법은 무었일까? 다행이도 이러한 문제를 해결하는 것은 어렵지 않다. Cost에 대한 gradient 값을 계속해서 확인해서 일정한 임계값($\tau$)을 넘어 갈 경우 이 값을 줄여주면 된다. 여기서는 다음과 같은 식이 사용된다.

$\tilde{\nabla}= \begin{cases} \tau \frac{\nabla}{||\nabla||},~~~~&\text{if}||\nabla||>\tau\\ \nabla,&\text{otherwise} \end{cases}$

이러한 방법은 gradient clippikng이라고도 불린다.

Vanishing Gradient

Vanishing gradient는 exploding과 다르게 큰 문제점으로 받아들여진다. gradient가 vanishing하는 과정에 대한 수식적인 소개가 note에는 나와있지만 여기서는 생략한다. vanishing gradient의 가장 큰 문제점은 이러한 문제를 해결할 방법이 거의 없다는 것이다. 그리고 우리는 vanishing gradient가 어떤 원인으로 발생하는지 구별하는 것이 어렵다. 예를 들면, lack of dependency에 의한 것인지, 혹은 underlying function때문인지 아니면 parameter setting이 잘못된 것인지 구분하기가 어렵다.

CNN을 활용한 주요 Model - (4) : Semantic Segmentation

2018-07-14T04:47:35+00:00

CNN을 활용한 주요 Model - (4) : Semantic Segmentation

CNN을 활용한 최초의 기본적인 Model들 부터 계속해서 다양한 구조를 가지는 많은 모델들이 계속해서 나오고 있다. 이번 포스트에서는 아래의 분류를 기준으로 CNN의 주요 모델들에 대해서 하나씩 알아 보도록 하겠다.

Modern CNN
- LeNet
- AlexNet
- VGG Nets
- GoogLeNet
- ResNet
Image Detection
- RCNN
- Fast RCNN
- Faster RCNN
- SPP Net
- Yolo
- SDD
- Attention Net
Semantic Segmentation
- FCN
- DeepLab v1, v2
- U-Net
- ReSeg
Image Captioning

이번 포스트에서는 Sematic Segmentation을 위해 만들어진 모델들에 대해서 소개한다. Semantic Segmentation 문제에 대해 먼저 소개를 하자. 우선 Segmentation을 먼저 설명하면, Detection이 물체가 있는 위치를 찾아서 물체에 대해 Boxing을 하는 문제였다면, Segmentation이란, Image를 Pixel단위로 구분해 각 pixel이 어떤 물체 class인지 구분하는 문제다.

아래 그림이 Image문제에 대한 분류를 잘 설명했다. 출처 : http://ataspinar.com/2017/12/04/using-convolutional-neural-networks-to-detect-features-in-sattelite-images/

그리고 Segmentation은 두가지로 나뉜다. Semantic Segmentation과 Instance Segmentation로 구분되는데 이번에 소개할 Semantic Segmentation은 pixel단위로 물체를 구분한뒤 각각의 물체가 어떤 class인지만 구분 하는 문제고, Instance Segmentation이란 같은 class이더라도 다른 것이라면 구분하는 문제라 할 수 있다.

(출처 : http://research.sualab.com/computer-vision/2017/11/29/image-recognition-overview-2.html) Instance Segmentation에서는 각각의 사람들을 다른 사람으로 구분한 것을 볼 수 있다.

Segmentation은 자율주행 자동차에서 매우 중요한 기술로 많은 모델들이 소개 되었다. 많은 모델 중 몇가지만 알아보도록 한다.

FCN

FCN이란 Fully Convolutinal Network의 약자로, 2015년 Fully Convolutional Network for Semantic Semgentation에서 소개됬다. FCN은 최초의 pixelwise end to end 예측 모델로 많은 의미를 가진다.

FCN에서 가장 중요한 부분은 이름에서 나와있듯 Convolution layer만을 사용했다는 것이다. 기본적으로 CNN 모델에서는 모델 뒤쪽에서 Fully Connected layer가 나오는데, FCN에서는 FC Layer 대신 1x1 Convolution layer를 사용했다는 점이다. 이렇게 사용한 이유에 대해 추측을 해보자면, 우선 Fully Connected layer를 사용하기 위해서는 고정된 input size를 가질 수 밖에 없다. 그리고 FC layer를 지나는 순간 각 pixel에 대한 위치정보는 소실된다. 따라서 FCN은 모든 Network를 Convolution layer만 사용함으로써 input size의 제한을 받지 않고, 위치정보를 보존할 수 있게 되었다.

FCN의 Architecture는 크게 3단계정도로 나뉜다.

Feature를 추출하는 Convolution 단계
뽑아낸 future에 대해 pixelwise prediction 단계
classification을 한뒤 각 원래의 크기로 만들기 위한 Upsampling 단계

이러한 단계를 거친 후 각 pixel에 class따라 색칠을 한뒤 Segmentation 결과를 보여준다. 세부적인 Architecture에 대한 소개를 하기보단 여기서 사용된 주요한 개념들에 대해서 소개를 한다.

Convolutionalization

FCN은 Fully Connected Layer를 사용하지 않고 1x1 Convolution Layer를 사용했다고 했는데, 논문에서 이러한 1x1 Convolution을 Convolutionalization이라 표현했다. 그림 중간의 256크기의 matrix가 4096의 크기로 reshape된 것을 볼 수 있다. 이렇게 reshape을 한 후 여기에 1x1 Convolution을 진행한다. 하지만 이렇게 크기를 줄인다면 output dimension이 줄어들어 원래 크기의 image에 대해 segmentation을 할 수 없게 된다. 따라서 다시 크기를 원래 size로 만들어 줘야 한다. 즉 Upsampling 단계가 필요하다.

Upsampling

FCN에서 feature extraction을 크기가 줄어 하나의 pixel이 원래 image의 32x32크기를 나타낸다. 여기서 다시 크기를 키우기 위해 32x32의 크기로 바로 만든다면 많은 정보들이 소실되고 정확도 또한 떨이지게 된다. 따라서 여기서는 1/32 크기만을 이용하는 것이 아니라 이전 Layer에서의 1/16크기와 1/8에서의 값도 같이 사용한다. 이전의 layer들의 값을 다른 연산을 거치지 않고 Skip하여 마지막에서 같이 합쳐서 사용하게 된다. 따라서 이러한 과정을 ‘Skip Layer’ 혹은 ‘Skip Connection’이라 부른다.

그림을 보면 이전의 Pooling Layer의 값을 가져와 더하는 것을 볼 수 있다. 이렇게 여러 크기의 값들을 Upsampling 한 것들을 합치는 것의 효과는 다음의 그림을 통해 확인하자.

DeebLab v1, v2, v3

최근 Segmentation 분야에서 State-of-art한 성능을 보여주는 DeepLab의 3번 째 versio이 오픈소스로 공개가 되어 많은 사람들의 주목을 받았다.(DeepLab. v3 Github)

DeepLab은 2015년 처음으로 나온 DeepLab. v1 인 Semantic Image Segmentation With Deep Convolutional Nets And Fully Connected CRFs(PaPer)을 시작으로 2016년 DeepLab v2(Paper), 그리고 올해 오픈소스로 나온 DeepLab v3까지 Semantic Segmentaion분야에서 높은 성능을 보여줬다.

DeepLab v2는 v1과 Atrous Convolution과 Fully Connected CRF(Conditional Random Field)를 사용한다는 점에서 비슷하지만 v2에서는 Atrous spatial pyramid pooling을 사용해서 Multiple sclae에 대응하는 방법이 개선되었다.

여기서는 DeepLab v2만 다룰 예정이다. v1과 v3에 대해서는 위의 링크를 참고하길 바란다.

DeepLab. v2에서 주목했던 문제들은 다음과 같다.

Reduced feature resolution
Reduced Local accuracy
Existence of objects at multiple scale

Deep Lab. v2에서는 위의 세 가지 문제를 다음을 사용해서 해결하려 한다

Reduced feature resolution
- Atrous Convolution
Reduced Local accuracy
- CRF(Conditional Random Field)
Existence of objects at multiple scale
- Atrous Spatial pyramid pooling

위 3가지 기술들에 대해 하나씩 살펴보자.

Atrous Convolution Classification 문제와는 달리 Image를 Pixel별로 구분해야 하는 Segmentaion에서는 CNN의 Layer가 깊어질수록 Feature의 크기가 작아지는 특징이 단점으로 작용했다. 따라서 이러한 Reduced Feature Resolution 문제를 Atrous Convolution을 사용해 해결했다.

Atrous Convolution이란 의미적으로 구멍 뚫린 Convolution이라 해석하면 될 것이다. 아래 논문의 그림을 보자.

그림의 위쪽은 일반적인 Convolution과정이고 아래는 Atrous Convolution을 의미한다. 중간중간 Hole(중간중간을 0으로 만듬)을 만들어서 좀 더 먼 쪽과 Convolution을 진행한다. 이런 과정을 통해 모델은 좀더 Dense한 Feature를 학습한다.

위의 그림을 보면 Atrous Convolution의 효과가 직관적으로 보인다. 아래의 빨간 화살표가 rate=2로 Atrous Conv를 실행한 것인데 위의 일반적인 Conv에 비해 Receptive Field 가 넓어 실제 그림과 비슷한 region을 얻는 것을 볼 수 있다.

Conditional random field

이제 큰 그림을 줄이면서 각 pixel에 대한 feature를 얻었으니 다시 Segmentation을 위해 다시 image를 늘리는 과정을 해야 한다. 아래 그림과 같이 Bilinear Interpolation만을 수행하면 원래 Image의 Segment를 정확히 얻지 못하는 것을 볼 수 있다.

따라서 Conditinal Ramdom Field를 사용해서 더욱 정확한 Segment를 얻는다. 아래의 그림은 CRF를 반복할 수록 더욱 정확한 Segment를 얻는 과정을 보여준다.

Atrous spatial pyramid pooling(ASPP)

DeepLab v1에서는 크기가 다른 물체들이 있을 떄 이를 잘 Segmentation하지 못하는 문제가 있었는데 v2에서는 ASPP를 사용해서 이를 해결했다.

ASPP란 특정 레이어 대해서 Atrous Convolution을 여러 rate를 이용해서 진행한 후 결과들을 합치는 방법이다. 아래의 그림을 보자.

rate 6, 12, 18, 24로 각각 convolution을 한 후 이들을 합치는 과정을 Atrous Spatial Pyramid Pooling 이라 한다.

위의 3가지 방법들을 합친 DeepLab v2의 전반적인 진행과정은 다음 그림과 같다.

여기까지가 DeepLab에 대한 설명이였다.

출처

정보이론 : 엔트로피, KL-Divergence

2018-07-12T06:47:35+00:00

정보이론 : 엔트로피, KL-Divergence

지난 포스트에서 소개했던 것 처럼 정보이론이란 정보의 양을 측정하는 분야이다. 그리고 그 정보의 양을 표현하는 개념이 엔트로피(Entropy)이다. 그리고 정보를 전달할 때는 비트의 단위로 전달을 하게 된다.

셰넌은 그의 논문에서 정보를 ‘불확정성’ 또는 ‘불확실성’으로 표현했다. 즉 어떤 사건에 대해 불확실성이 커질수록 정보량이 많아진다는 것이다.

직관적인 이해를 위해 설명을 하면, 어떠한 사건을 누군가에게 통신을 통해 전달해야 한다고 가정을 하자. 확률이 높은 사건이 설명하기 쉽겠는가, 확률이 희박한 사건을 설명하기 쉽겠는지에 대해 생각해보면 된다. 예를 들어 동전던지기를 설명하려면 앞면, 뒷면 두가지 경우중에 한가지가 나왔다는 것을 전달하면 되지만 주사위 던지기의 경우에는 1부터 6까지의 경우 중에서 하나가 나왔다는 것을 전달해야 한다. 이 두가지 경우중 전달해야 할 정보량이 많은 것은 당연이 후자일 것이다.

Self-Information

확률 $p$를 가지는 사건(메시지) $A$ 의 정보를 정의하는 것을 Self-Information(or surpisal)이라고 한다. 어떤 메시지 $m$에 대한 self-information은 다음과 같이 정의된다. (여기서 log는 밑이 2인 log를 뜻 한다.)

$I(m)=log\bigg(\frac{1}{p(m)}\bigg)=-\log(p(m))$

정보량은 확률에대해 $log_2$를 씌운 값인데, 확률은 $0$~$1$값을 가지므로 음수값이 나오게된다. 그러나 정보량은 양수의 값을 가져야 하므로 -를 씌워줘서 양수로 만들어준다. 그리고 항상 로그의 밑이 2가 되는 것은 아니다. 경우에 따라 맞는 수를 사용하면 된다. 예를 들어 Discrete한 사건이 아니라 Continuous한 random variable에 대해서 정보량을 측정할 떄에는 보통 e를 밑으로 하는 log를 사용한기도 한다. 그리고 이 정보량인 $I(m)$의 단위는 비트(bit)이다.(여기서 밑을 2로한 이유이기도 하다.) 예를 들어서 확률 1/8을 가지는 사건에 대한 정보량은 $-log(\frac18)$로 3이된다. 즉 이 메시지를 전달하기 위해서는 3bit가 필요하다는 뜻이 된다.

Entropy

Self-Information은 하나의 메시지에 대한 자기 자신의 정보량을 나타냈다. 엔트로피란 어떤 다수의 메시지들(메시지 집합$M$)에 대해서 각각의 정보량을 평균한 값을 의미한다. 평균값을 계산하는 방법이 메시지 공간($M$)의 사건들이 Discrete한 경우와 Continuous한 경우 계산하는 방법이 다르므로 두 가지 수식을 나눠서 설명한다.

메시지 집합 $M$에 대한 엔트로피(Discrete)

$H(M)=E[I(M)]=\sum_{m\in M} p(m)I(m)=-\sum_{m\in M}p(m)\log p(m)$

여기서 $E[]$는 평균값(기대값)이다. 즉 평균을 계산하는 것이므로 각 변수와 그 변수에 대한 확률들을 더한 값이 엔트로피가 된다.

메시지 집합 $M$에 대한 엔트로피(Continuous)

$H(X)=E[I(X)]=\int p(x)I(x) dx = -\int p(x)\log(p(x))dx$

모든 변수 $x$에 대한 적분값으로 의미적으로는 기대값을 계산하는 것이므로 위의 식과 같다고 할 수 있다. (여기서는 보통 $\log_2$대신 $\ln$을 사용한다.)

그리고 어떤 메시지 공간에 대해 엔트로피가 최대가 되는 경우 또한 중요하다. 공간 $M$에 대해서 각 사건들이 uniform distribution이 되는 경우 엔트로피가 최대가 된다. 즉 각 사건의 확률이 $p(m)=\frac1M$으로 동일하다면 엔트로피가 최대가 된다. ($E[M]=\log|M|$)

Joint Entropy

Discrte한 두 변수 $X,~Y$에 대한 entropy인 Joint Entropy는 다음과 같이 정의된다.

$H(X,Y)=E_{X,Y}=[-\log p(x,y)]=-\sum_{x,y}p(x,y)\log p(x,y)$

만약 $X,~Y$가 independent하면, Joint Entropy는 각각의 Entropy의 합이 된다. Continuous한 경우의 Entropy도 Sigma 대신 Integral을 사용해서 계산하면 된다.

Cross Entropy

Cross Entropy는 Joint Entropy와 수식적으로 비슷해 혼동되는 경우가 있는데, 다른 개념이다. 두 확률 분포 $p$와 $q$에 대해서 분포$p$ 대신 $q$를 사용해 분포 $p$를 설명할때 필요한 정보량을 Cross Entropy라 한다.

수식을 보자.

$H(p,q) = E_p[-\log(q)] = -\sum_xp(x)\log q(x)$

정보를 나타내는 $log$값에 $p(x)$대신 $q(x)$를 사용한 것을 볼 수 있다. 즉 분포 $q(x)$를 활용해서 $p$를 설명하기 위해 $p$의 기대값을 구한 식이다.

Conditional Entropy

어떤 특정한 값을 같는 random variable $Y=y$에 대해 $X$의 conditional entropy는 다음과 같다.

$H(X|Y=y)=E_{X|Y=y}[-\log p(x,y)]=-\sum_{x\in X}p(x|y)\log p(x|y)$

conditional entropy는 다음의 식이 성립한다

$H(X|Y) = H(X,Y) - H(Y)$

Kullback-Leibler divergence(KL-Divergence)

KL-Divergence에 대한 수식을 설명하기 전에 개념의 Idea부터 얘기를 해보자.

우리가 어떤 확률 분포 $p(x)$를 가지고 있다. 이 확률 분포를 전송을 해서 정보를 전달을 해야하는데 각각의 변수$x$에 대해 $p(x)$를 모두 전달하기에는 정보량도 많고 전달할 수단이 부족하다고 가정하자. 이때 우리는 분포 $p(x)$를 전달하기보다 이미 정의된 다른 확률 변수$q(x)$를 대신 전달하려는 생각을 했다. 이렇게 되면 어떤 분포인지, 그리고 분포의 특정 몇가지 값들만 전달하면 되므로 정보량 자체가 엄청나게 줄고 그래서 전송 또한 가능해진다.

그러면 이제 새로운 문제에 봉착한다. 과연 어떤 분포 $q(x)$를 선택해서 보내야 하는가이다. 최대한 분포$p(x)$와 유사한 분포를 선택해야할 것이다. 이때 분포 $p$와 $q$의 유사한 정도를 계산하는 방법이 KL-Divergence이다.

KL-Divergence는 그 값이 작을 수록 두 분포가 유사하다는 것을 의미하고 값이 0이 되면 두 분포가 같은 분포라는 뜻이 된다.

KL-Divergence 수식을 위해서는 Cross Entropy를 사용한다. $p$를 $q$로 설명하는 정보량을 뜻하는 Cross Entropy에서 $p$가 자기자신을 설명하는 정보량인 $p$의 엔트로피의 차이가 KL-Divergence가 된다. 수식을 보자

$\begin{align*} D_{KL}(p||q) &= H(p,q)-H(q)\\\\ &=-\sum_{x\in X} p(x)\log q(x)-(-\sum_{x\in X}p(x))\\\\ &=\sum_{x\in X}p(x)\log\frac{p(x)}{q(x)} \end{align*}$

두 엔트로피의 차이를 계산함으로써 $p$대신 $q$를 사용했을 때의 정보량의 차이를 계산하는 식이다. 그리고 KL-Divergence를 거리함수로 생각하는 경우도 있는데 엄밀하게 말하면 거리함수가 아니다. 왜냐하면 p,q를 바꿨을 때 두 값이 같아야 하지만 계산해보면 다르기 때문에 엄밀하게 거리함수라 할 수는 없다.

이번 포스트에서 정보이론의 내용 중 정보량을 다루는 개념들에 대해서 알아보았다. 다음 포스트에서는 정보를 압축하는 방법들에 대해 다뤄보도록 한다.

정보이론

2018-07-12T05:47:35+00:00

정보이론

정보이론이란 최대한 많은 데이터를 매체에 저장하거나 채널을 통해 통신하기 위해 데이터를 정량화하는 응용수학의 한 분야이다.
출처 : 위키피디아

정보이론은 1948년 Claude E. Shannon에 의해 처음 소개되었으며 정보의 통신, 저장, 부량(Quantificaiton)에 대해 연구하는 분야이다. 정보이론을 활용한 분야로는 대표적으로 무손실 데이터 압축(e.g. ZIP files), 손실 데이터 압축(e.g. MP3, JPEG), 채널 코딩(e.g digital subscriber line(DSL))등이 있다. 보이저계획의 성공, compact disk, 휴대전화 개발등 많은 분야에서 중요한 역할을 했다.

정보이론의 가장 핵심인 내용은 앤트로피(Entropy) 이다. 엔트로피란 무작위 사건에 대한 결과 또는 random variable에 대한 불확실성을 포함하는 정보의 양이다. 예를 들어, 앞면 혹은 뒷면만 나오는 동전던지기의 결과에 대한 엔트로피와 6면체 주사위를 던졌을때 나오는 결과에 대한 엔트로피를 비교하면 후자가 더 크다.

정보량 뿐만 아니라 정보이론에서 주요하게 다뤄지는 다른 내용들은 상호 의존정보(mutual information), 채널용량(channel capacity), error exponet, 상대 엔트로피(relative entropy)등이 있다.

정보이론에 대해 모든 것을 다루기에는 어렵기도 어려우며, 양이 너무많아 정보량에 관한 내용과 압축에 관한 내용만 다음 포스트를 통해 소개하겠다. 다른 부분에 대해서는 아래 작성된 위키피디아의 목차에 대해 소개와 link를 통해 알아볼 수 있다.

출처 : 위키피디아

Chater 5: Neural Laguage Models

2018-07-11T04:47:35+00:00

Chapter 5 Neural Language Models

이 내용은 Newyork University의 조경현교수님의 DS-GA 3001강의 lecture note중 Neural Laguage Models단원을 정리한 내용입니다.

5.1 Language Modeling

Machine이 우리의 언어를 이해하는 방법은 어떻게 될까? 가장 basic한 방법으로는 문장들이 얼마나 유사(Likeliness)한지에 대해 이해하는 것이다. 아래의 두 문장을 보자.

“Colorless green ideas sleep furiously”
“Jane and me went to see a movie yesterday”

첫 번째 문장은 문법적으로 완벽한 문장이다. 하지만 문장을 사람이 이해하려해도 어떤 의미인지 쉽게 받아 들여지지 않는다. 단어들끼리의 유사도가 매우 안맞는 문장이다. 그에 반해 두 번째 문장은 문법적으로는 잘못된 문장이다. me 대신 i가 들어가야 하지만, 저 문장을 이해하는데는 어려움이 없이 쉽게 이해 된다.

따라서 우리는 기계에게 문장을 이해시키는 방법으로 유사도를 통한 의미적인 부분을 학습시킬 것이다. 물론, 문법적인 부분도 해야 하겠지만 이는 어려운 문제이다.

5.2 What if those linguistic structures do exist

Language Modeling에 대해 통계학적 접근법은 문법적으로 완벽한 문장을 유사하지 않다고 결론 지을 수 있다. 이러한 문제는 문장들간의 유사도에 대해서 다루는 문제를 확률 모델로 만들 수 있을 것이다. 주어진 문장 $S$가 있다고 하자, 이때 확률 $P(S)$는 어떻게 구할 것인가? (여기서 $P(S)$는 간략하게 유사도와 문법적 정확도를 같게 보는 것으로 해석할 것이다.) 우선 $S$에 의해 만들어지는 잠재적 언어학 구조를 $G$라 가정하자. 아래와 같은 식을 얻을 수 있다.

$p(S,G) = p(S|G)p(G)$ $p(S)=\sum_G p(S, G)$

하지만 여기서 $G$는 정해진 것이 아니므로, 무한할 수 있다. 따라서 실제 계산을 위해서는 Lower bound를 사용해 아래와 같은 식을 사용해 $p(S)$를 근사한다.

$p(S)=\sum_G p(S, G) \ge p(S,\hat G)$ $where\;\hat G = argmax_G p(S,G) = argmax_G p(G|S)$

하지만 이러한 모델링에도 문제점이 있다. 첫 째로, $G$를 사용하는 것에 대해 명백하지 않다. 둘 째로는 이러한 형식들이 의미적으로 불확실하다.

이제부터는 model-free한 접근법에 대해서 알아볼것이다.

5.1.2 Quick Note on Linguistic Units

“언어학적 최소 단위가 무었일까?” 위 질문에 대한 대답은 음소(phoneme)가 될 것이다. 하지만 “음소가 언어를 이해할 수 있는 단계인가?” 에 대해서는 아니라고 할 것이다. 이러한 low-level의 unit들 (음소, 글자)는 의미를 수반하지 않기 떄문에 이해할 수 있는 단계가 아니다. 따라서 우리는 한 단어를 최소 단위로 의미를 이해할 수 있다. 그러나 여기에도 문제가 있다. ‘어떤것을 단어로 볼 것인가?’ 보통은 띄어쓰기(sequence of non-blank characters)를 기준으로 단어를 구분한다. 그러나 구두점과 같은 것들이 나오면 단어에 대한 정의가 애매해진다.

“hello,” , “hello.”, “hello!”, “hello?”, ““hello””, “‘hello’” 위의 hello들은 모두 같은 단어이지만 구두점 때문에 다른 의미로 해석될 수 있다.

뿐만 아니라 중국어 같은 언어에서는 띄어쓰기가 사용되지 않아서 위와 같은 정의를 적용시킬 수 없다. 따라서 우리는 이 최소단위에 대한 정의에 대한 고민을 해야 할 것이다. 이 분야는 물론 지금도 계속 연구되고 있고 답이 없는 분야이다. 즉, character와 word 사이의 적절한 liguistic unit이 있는지를 찾아야 한다.

5.2 Statical Laguage Model

Liguistic unit에 상관없이, 어떤 문장$S$는 $T$개의 각각의 symbol들로 구분될 수 있다.

$S=(w_1, w_2, ... ,w_T)$

각 symbol들은 vocabulary라는 가능한 모든 symbol이 모여있는 집합의 원소이다.

$V= \{v_1, v_2, ... , v_{|V|}\}$

Laguage Modeling 문제는 Sentence에 대해 확률 $P(S)$를 할당하는 model을 찾는 문제이다. 그러나 우리는 확률 분포에 대한 정보가 없을 것이고, Data로 부터 학습을 해야 할 것이다. $D$를 $N$개의 Sentence를 가지고 있는 Data라 하자.

$D=\{S^1, S^2, ... S^N\}$ $S^n = (w_1^n, w_2^n, ... w_{T^n}^n)$

$T^n$이라는 표현은 각 sentence들의 길이가 다르다는 것을 의미한다.

이제 주어진 Data $D$에 대해 Sentence $S$의 확률을 다음과 같이 정의하자.

$p(S) = \frac{\sum_n^NI_{S=S^n}}{N}$

여기서 $I$는 indicator function으로 동일한 Sentence면 1, 아니면 0을 주는 함수이다.

$I_{S=S^n}=\bigg\lbrace\begin{matrix} 1, & \text{if}\ \ S=S^n \\ 0, & \text{otherwise} \end{matrix}$

위의 확률은 sentence $S$가 Data 내에서 몇번 나왔는지와 같다.

5.2.1 Data Sparsity/Scarcity

Laguage model에서 가장 중요한 issue는 corpus의 크기가 얼마나 큰가이다. 즉 dataset의 크기가 중요한데, 실제 세계의 사용가능한 모든 문장을 data로 가지고 있을 수는 없다. $|V|$개의 symbol을 가지는 vocabulary가 있다고 하자. 각 sentence의 최소한 $T$개의 symbol가진다. 이러한 vocabulary는 충분히 큰 크기가 될 것이다(100k ~ 1M). 그럼에도 불구하고, 많은 실제로 사용할만한 문장임에도 불구하고 corpus에 포함되지 않을 수 있다. 그 예를 한번 찾아보자. Google Books Ngram Viewer라는 서비스는 Google Books의 문장들이 모두 모여있는 거대한 corpus를 나타낸다. 여기서 “I like llama”라는 문장을 검색해보자, 이 문장은 충분히 사용할만한 문장임에도 불구하고 결과가 나오지 않는다. 이전 part에서 정의한 sentence에 대한 확률을 생각해보자, “i like llama”라는 문장은 corpus에 존재하지만, 많이 등장하지는 않을 것이다. 따라서 데이터셋이 매우 크므로 확률은 거의 0에 수렴할 것이다. 이러한 문제를 data sparsity 라 부른다. 즉 trainning set이 전체 input space를 cover하지 못하는 경우를 뜻한다.

5.3 n-Gram Language Model

Data Sparsity 문제는 sentence의 최대 길이가 커질수록 악화된다. 우리는 이 사실에 착안해서 straightforward한 접근법을 사용한다. (limit the maximum length of phrases/sentences we estimate a probability on) 이러한 idea는 n-Gram language model의 base가 되었다. n-Gram 모델에서는 위에서 정의한 sentence에 대한 확률을 재정의한다.

$p(S)=p(w_1,w_2,...w_T)=p(w_1)p(w_2|w_1)\dotsm p(w_k|w_{<k})\dotsm p(w_T|w_{<T})$

여기에서 $w_{<k}$는 k 번째 symbol 이전의 모든 symbol들을 뜻한다. 아래의 식과 같다.

$p(w_k|w_{<k})\approx p(w_k|w_{k-n},w_{k-n+1},...,w_{k-1})$

따라서 Sentence의 확률이 다음과 같이 정의된다.

$p(S)\approx \prod_{t=1}^Tp(w_t|w_{t-n},...w_{t-1})$

위 식이 의미하는 것은 sentence내의 symbol은 이전의 $n-1$개의 symbol들에 의해 predictable하다는 것이다. 예를 들어 “In Korea, more than half of all the residents speak Korean” 문장을 보면 마지막의 ‘Korean’이라는 단어는 사람과 언어 두가지 의미를 가지는데, 그 이전의 speak과 Korea라는 단어에 대해 상대적인 확률로 생각을 해보면 언어를 뜻하는 것이 더 타당하다는 것을 알 수 있다. 즉 n-Gram 모델을 사용하면 이전의 symbol에 대한 정보를 가지고 현재 symbol의 의미를 파악하기 때문에 유용하다는 것을 알 수 있다. 위의 예를 통해 보면, 확률 추정의 정확도와 $n$의 크기에 따른 통계적인 효율은 trade-off 관계에 있다는 것을 알 수 있다. 즉, $n$의 값이 커질수록, conditional distribution은 더 나은 결과를 만들 것이지만 data sparsity는 커져 정확도가 떨어질 수 있다.M

n-gram Probablity Estimate

n-gram conditional probabilty는 trainning corpus를 통해 계산할 수 있다. 아래의 식을 보자.

$p(w_k|w_{k-n},w_{k-n+1},...,w_{k-1})=\frac{p(w_{k-n},...w_{k-1},w_k)}{p(w_{k-n},...,w_{k-1})}$

여기서 분모는 다음과 같이 계산할 수 있다.

$p(w_{k-n},...,w_{k-1})=\sum_{w^\prime\in V}p(w_{k-n},...,w_{k-1},w^\prime)$ $p(w_{k-n},...,w_{k-1},w^\prime)\approx \frac{c(w_{k-n},...w_{k-1},w^\prime)}{N_n}$

여기서 $c(\cdot)$가 의미하는 것은 trainning corpus에서 주어진 n-gram의 등장 횟수이다. 그리고 $N_n$은 trainning corpus에서의 모든 n-gram의 수 이다. 마지막으로 다음과 같이 식을 정리한다.

$p(w_k|w_{k-n},...,w_{k-1})=\frac{\cancel{\frac{1}{N_n}}c(w_{k-n},...,w_{k-1},w^\prime)} {\cancel{\frac{1}{N_n}}\sum_{w^\prime\in V}c(w_{k-n},...w_{k-1},w^\prime)}$

5.3.1 Smoothing and Back-Off

n-gram model의 가장 큰 issue는 어떤 n-gram을 포함하는 sentence에 대해 얼마다 다른 n-gram들과 유사한지와 상관없이 0의 확률을 갖는 것이다. 예시를 통해 이러한 경우에 대해 살펴보자.

“I like llama which is a domesticated South American camelid”

위의 문장에 대한 확률은 다음과 같이 계산될 것이다.

$\begin{align*} &p(\text{"I","like","llama","which","is","a","domesticated","South","American","camelid"}\\ &=p("\text{I}")p("\text{like}"|"\text{I}")\underbrace{p("\text{llama}"|"\text{I}","\text{like}")}_{=0}\dotsm p("\text{camelid}"|"\text{South}","\text{American}")\\ &=0 \end{align*}$

위 식과 같이 특정 n-gram 확률 때문에 전체가 0이되는 문제를 해결하기 위해 corpus의 크기를 키우면 되지 않을까 라고 생각한다. 하지만 이러한 “data sparsity” 문제는 corpus의 크기와 상관없이 statistical modeling에서 항상 발생하는 문제이다. 그렇다면 어떻게 해결해야 할 것인가? 방법은 기존에 존재하지 않는 n-gram에 대해 작은 특정 값을 갖도록 하는 것이다. 그러면 기존에 나오지않은 n-gram이더라도 특정 값을 가지므로 0이 되는 문제는 발생하지 않을 것이다. 식을 아래와 같이 구현함으로써 이 방법을 사용할 수 있다.

$\begin{align*} p(w_k|w_{k-n},...,w_{k-1})&=\frac{\alpha+c(w_{k-n},...,w_{k})}{\sum_{w^{\prime}\in V}(\alpha+c(w_{k-n},...,w^\prime))}\\ &=\frac{\alpha+c(w_{k-n},...,w_{k})}{\alpha|V|+\sum_{w^{\prime}\in V}c(w_{k-n},...,w^\prime)} \end{align*}$

$\alpha$는 scalar 값으로 보통 다음의 범위로 정한다. $0<\alpha\le1$

unseen n-gram 을 위와 같이 해결하는 방법을 smoothing 기법(부족한 데이터를 해결하는 방법)이라 표현하고 위와 같이 특정 scalar값을 더해주는 방법을 Additive Smoothing 혹은 Lidstone Smoothing이라고 표현한다. 그 중 $\alpha$값으로 1을 지정하는 방법은 Laplace Smoothing이라고 한다.(Laplace는 한번도 안나온 데이터에 대해 최소 한번은 나왔다고 지정하는 방법) 하지만 직관적으로 봐도 위 방법은 효율일 잘 안나올 것 같다. unseen n-gram들에 대해 모두 다 똑같은 빈도수를 준다는 점에서 문제가 발생한다.

이에 대한 해결책은 n-gram 확률을 interpolation 방법을 통해 smoothing하는 것이다. 수식은 다음과 같이 정의한다.

$\begin{align*} p^S(w_k|w_{k-n},...,w_{k-1})=&\lambda(w_{k-n},...,w_{k-1})p(w_k|w_{k-n},...,w_{k-1})\\ &+(1-\lambda(w_{k-n},...,w_{k-1}))p^S(w_k|w_{k-n+1},...,w_{k-1}) \end{align*}$

위 식에 따르면 n-gram 확률은 이전 n-gram확률에 의해 재귀적으로 계산되는 것을 볼 수 있다. 이제 중요한 것은 $\lambda$값을 어떻게 지정해야할까 이다. 간단한 방법은 데이터에 맞추는 방법이다. 즉 데이터에서 출현빈도에 초점을 맞추는 방법이다. $\lambda$값까지 정한뒤 일반화하면 다음과 같다.

$p^S(w_k|w_{k-n},...,w_{k-1})= \begin{cases} \alpha(w_k|w_{k-n},...,w_{k-1}),~~\text{if}~~c(w_{k-n},...,w_{k-1},w_k)>0\\ \gamma(w_{k-n+1},...,w_k)p^S(w_k|w_{k-n+1},...,w_{k-1}),~otherwise \end{cases}$

여기서 $\alpha$값과 $\gamma$값의 선택에 따라 여러 techniques으로 나뉜다.

대표적인 smoothing 방법은 KN smoothing과 GT smoothing 방법이다. 이에 대한 설명은 생략한다.

5.3.2 Lack of Generalization

n-gram 모델이 대부분의 상황에서 잘 동작하지만, 몇몇 특수한 상황에서 아쉬운 상황을 생긴다. 그 이유 중 하나는 Lack of Generalization인데, 여기서 말하는 Generalization은 아래의 예를 보며 이해를 하자.

Chases a rabbit
Chases a cat
Chases a dog

세 문장을 보면 우리는 Chases라는 단어 뒤에 오는 단어에 대한 패턴을 인식할 수 있다. 즉 사람은 일정한 단어들을 보고 그것들의 상위개념들을 이해할 수 있다. 하지만 n-gram 모델에서는 이런 상위개념들로 일반화시키는 것을 할 수 없다.

만약 n-gram 모델에게 이런 일반화 과정들을 이해시키려면 각 단어의 정의에 대한 사전을 이해시키거나 각 단어의 정확한 뜻을 알려주는 방법인데 이 방법을 해결한다는 것은 정의를 text로 알려주는 한 결국 Language를 이해시키는 것과 똑같기 때문에 불가능 하다.

다음 장에서는 이런 Lack of Generalization문제를 어느정도 해결하는 방법에 대해서 살펴보도록 하자.

5.4 Neural Language Model

n-gram 모델은 현재 단어 이전의 n개의 단어에 대해 현재 단어에 대한 조건부 확률을 계산하는 것이였다. 즉 n개의 단어에 대해 확률을 구하는 함수를 찾는 것이다.

$p(w_k|w_{k-n},...,w_{k-1})=f^{w_k}_\theta (w_{k-n},...,w_{k-1})$

위 함수를 정의하기 위해 가장 먼저 해야 할 것은 input값을 정의하는 것이다. 사전의 단어에 대한 정보를 최소화 해야하기 때문에 우리는 one-hot encoding 방식을 사용할 것이다. input은 다음과 같이 정의된다.

$w_i=[0, 0,...,1,...0]^\intercal\in{0,1}^{|V|}$

이제 일반적인 Neural Net과 비슷한 방식으로 계산한다. 우선 간 단어 벡터에 가중치 행렬( $E\in\mathbb{R}^{|V| \times d}$ )을 곱해서 연속된 vector들을 구하자.

$p^j=E^\intercal w^j$

input값이 one-hot vector였던 것을 생각하자. 가중치 행렬과 곱해질 때 $w_k$는 1이 1개만 있으므로 가중치 행렬의 k번째 행과만 계산될 것이다. 따라서 가중치 행렬은 다음과 같이 각 벡터들의 모음으로 작성할 수 있다.

$E= \begin{bmatrix} e_1\\ e_2\\ \vdots\\ e_{|V|} \end{bmatrix}$

따라서 input과 가중치 행렬의 곱은 다음과 같이 정의된다.

$E^\intercal w_i = e_i$

이 식이 의미하는 바는 가중치 행렬의 i행 vecter인 $e_i$는 단어들중 i번째 단어를 포현하는 벡터로 해석될 수 있다는 점이다. 따라서 $e_i$벡터를 input값으로 사용할 것이다. 이제 input값이 n개의 vector를 concat한 뒤 non-linear하게 만들어 주면 모델링 과정이 끝난다.

$\mathbf{p}=[p^1;p^2;...;p^n]^\intercal$ $\mathbf{h}=\tanh(\mathbf{Wp+b})$

최종적으로 모델링을 사용한 조건부 확률은 다음과 같이 정의된다.

$p(w_n=k|w_1,...w_{n-1}) =\mu_k=\frac{\exp(u_k^\intercal h+c_k)}{\sum^{|K|}_{k'=1}\exp(u_{k'}^\intercal h+c_{k'})}$

5.4.1 How does Neural Language Model Generalize to Unseen n-Grams? - Distributional Hypothesis

이때까지 Neural language model에 대해서 소개했다. 이번에는 주로 unseen n-gram을 generalize하는 방법에 대해서 알아보도록 한다.

이전의 neural language model을 두개의 합수의 합성으로 만들어보자. ($f\circ g$) 먼저 $f$는 context word의 순열 또는 n-1개의 앞선 단어를 벡터로 만들어 주는 함수라고 한다.

$f:\{0,1\}^{|V|\times n-1}\rightarrow \mathbb{R}^d$

각 단어에 대해 $f$함수를 통과시킨 결과로 나온 $d$ 차원의 벡터를 $\mathbf{h}$라 하고 context vector라 부른다. 두 번째 단계인 $g$는 continuous vector인 $\mathbf{h}$를 단어 확률로 만들어 주는 함수이다. 이 단계에서 affine 변환과 softmax함수를 통한 일반화 과정이 포함된다. 이전에 사용된 확률 함수인 $g$를 다시 한번 살펴보자.

$\frac{\exp(u_k^\intercal h+c_k)}{\sum^{|K|}_{k'=1}\exp(u_{k'}^\intercal h+c_{k'})}$

간단한 형태로 보기위해 bias인 $c$를 빼고 확인해보자.

$\frac{\exp(u_k^\intercal h)}{\sum^{|K|}_{k'=1}\exp(u_{k'}^\intercal h)}$

$k$ 번째 확률은 output vector인 $u_k$(output matrix $\mathbf{U}$의 $k$ 번째 행)가 context vector인 $\mathbf{h}$와 잘 맞을 경우 커질 것이다. 즉 다음 단어로 k 번째 단어가 등장할 확률은 context vector인 $\mathbf{h}$와 해당 word vector인 $u_k$와 내적한 값에 비례할 것이다.

두 개의 context vector $\mathbf{h}_j$와 $\mathbf{h}_k$가 있다고 하자. 각 문맥은 단어들 간의 유사도(다음 단어의 조건부 분포가 서로 얼마나 유사한지)에 따라 결정된다.

context vector 를 고려한 특정 target 단어 $w_l$에 대한 확률을 보자.

$\begin{matrix} p^l_j=p(w_l|h_j)=\frac{1}{Z_j}\exp(\mathbf{w}_l^T \mathbf{h}_j)\\ p^l_k=p(w_l|h_k)=\frac{1}{Z_k}\exp(\mathbf{w}_k^T \mathbf{h}_j) \end{matrix}$

두 context(문맥)에 대한 확률의 비율은 다음과 같다.

$\frac{p^l_j}{p^l_k}=\frac{Z_K}{Z_j}\exp(\mathbf{w}_l^T(\mathbf{h}_j-\mathbf{h}_k))$

위 식을 보면, 두 context에 대한 확률이 같아질려면($\frac{p^l_j}{p^l_k}$) 아래의 식을 만족시켜야 한다.

$\mathbf{w}_l^T(\mathbf{h}_j-\mathbf{h}_k)=0$

위 식을 만족시키는 경우에 대해서 알아보자. 우선 단어 벡터인 $\mathbf{w}$는 0이 아니라 가정한다. 위 식이 0이 되려면 두 context 벡터의 값이 같아져야 한다. 즉 다시 말해, 두 context 벡터값이 서로 유사해져야 한다는 뜻이다.(이를 테면 유클리디언 거리가 가깝다) 이러한 상황이 의미하는 것이 무엇일까? 이것은 neural language model은 다른 주변의 n-gram은 먼 지점으로 투영하면서 동일한 단어에 따라 나오는 (n-1)-gram을 context 벡터 공간에서 비슷한 지점으로 투영해야 한다. 즉 이는 같은 단어에 대해 비슷한 확률을 주기 위해 필요하다. 만약 이와 같이 동일한 단어에 대해 context vector 공간의 다른 지점으로 투영한다면 우리가 예측해야할 다음 단어에 대한 확률이 다르게 나올 것이고 이는 좋지 않은 language model이다.

위의 설명에 대해 직관적인 이해를 위해 극단적인 예를 한번 들어보자. 아래의 세 문장을 보자

There are three teams left for the qualification
four teams have passed the first round
four groups are playing in the field

굵은 글씨들을 보자. 이 bigram의 각 첫 번째 단어가 context word이다. 그리고 neural language model은 이 context 단어 뒤에 나오는 단어의 확률을 예측해야 한다.

여기서 neural laguage model은 “three”와 “four”를 context space의 비슷한 지점으로 투영해야 할 것이다. 즉 이 두 단어의 context vector는 “teams”에 대한 비슷한 확률을 만들어야 한다. 그리고 각 target 단어인 “teams”와 “groups”은 각 vector가 유사해야 할 것이다.

이제 위의 세 문장을 학습시킨 neural language 모델에서 unseen n-gram인 “three group”에 대한 확률을 할당하는 것을 생각해보자. 위 문장으로 학습시킨 모델은 “three”의 context vector 와 “four”의 context vector는 context 공간에서 비슷한 지점으로 투영시킬 것이다. 따라서 “three”의 context vector에 의해 다음 단어가 “group”일 확률을 높게 계산할 것이다.

이러한 과정을 통해 neural language 모델은 unseen n-gram 에 적당한 확률값을 줄 수 있다. 위의 예를 통해 확인할 수 있는 점은 neural laguage 모델은 자동으로 다른 context vector들 사이의 유사도를 측정할 수 있다는 점이다.(target word가 다르더라도, 동시 등장확률에 의해)

실제 세계에서 우리의 언어는 “Distributional Hypothesis”를 만족하는 것은 자명하다. 즉 유사한 의미를 갖는 단어는 비슷한 위치에 등장한다. 따라서 단어들이 같이 등장하는 단어들을 관찰하면 단어의 잠재 의미를 뽑아낼 수 있을 것이다.

5.4.2 Continuous Bag-of-Words Language Model: Maximum Pseudo-Likelihood Approach

“왜 우리는 language modeling을 할 때 앞선 단어만 고려하는 것일까?” “앞선 단어만 의존한 단어 분포가 적합한 가정일까?”

위 두개의 질문에 대한 대답은 “꼭 그럴 필요는 없다” 가 될것이다. 우리는 특정 단어에 대해 앞선 단어가 아닌 해당 단어 앞 뒤로 $n$개의 단어를 고려하는 모델을 만들 수 있다. 이러한 모델이 Markov random field language model 이다.

Markov random field language 모델 (MRF-LM)에서 주어진 문장에서 각 단어는 랜덤 변수 $w_i$로 말할 수 있다. 그리고 둘러싼 $2n$개의 각 단어를 비방향 선(undirected edges)으로 각 단어를 연결할 수 있다. 여기서 연결된 선은 조건부 의존성(conditional dependency) 구조를 의미한다. 위의 그림이 n=1 일때의 MRF-LM을 그림으로 나타낸 것이다. 이 경우에 Markov random field의 확률은 각 그래프의 꼭지점(clique)의 potential 값들의 곱으로 표현된다. 여기서 potential이란 각 꼭지점에서 각 input 값이 random 변수인 positive 함수를 의미한다.

MRF-LM에서 두개의 랜덤 변수의 꼭지점을 제외한 모든 꼭지점에는 1의 potential을 할당한다.(즉, pairwise potential만을 사용한다) $i$ 와 $j$ 단어의 pairwise potential은 다음과 같이 정의된다.

$\phi(\mathbf{w}^i,\mathbf{w}^j)=\exp\big((\mathbf{E}^T\mathbf{w}^i)^T(\mathbf{E}^T\mathbf{w}^j)\big)$

여기서 $E$는 위에서 나왔던 가중치 행렬을 의미한다. 그리고 $\mathbf{w}^i$는 $i$번 째 단어의 one-hot vector이다. 위 식은 많은 pairwise potential 중 하나이고 다른 많은 경우도 있다.(가령 dot product로 정의 할 수도 있다)

위의 식과 함께 전체 Sentence의 확률은 다음과 같이 정의된다.

$p(w_1,w_2,...,w_T)=\frac1Z \prod_{t=1}^{T-n}\prod_{j=t}^{t+n}\phi(\mathbf{w}^t,\mathbf{w}^j)=\frac1Z \exp(\sum^{T-n}_{t=1}e^T_{w^t}e_{w^j})$

여기서 $Z$는 일반화 상수이다. 이 값은 potential의 곱을 확률로 만들어준다. 이 값을 전체 문장에 대해 계산하는건 불가능하기 떄문에 주어진 condition의 단어들에 대해 각 단어에 대해 조건부 확률을 계산한다.

조건부 확률을 계산할 떄는 각 단어에 대해 Markov blanket이라 불리는 부분에 포함된 단어의 값에 의해 계산된다. 여기서 Markov blanket이란 각 단어를 둘러싼 $n$개의 단어를 뜻한다. 즉 각 단어의 앞의 $n$개 뒤의 $n$개의 단어를 본다. 따라서 조건부 확률은 다음과 같이 정의 될 것이다.

$p(w^i|w^{i-n},...,w^{i-1},w^{i+1},...,w^{i+n})=\frac{1}{Z'}\exp\bigg(\mathbf{e}^T_{w^i}\bigg(\sum^n_{k=1}\mathbf{e}^T_{w^{i-k}}+\sum^n_{k=1}\mathbf{e}^T_{w^{i+k}}\bigg)\bigg)$

여기서 일반화 상수인 $Z’$은 다음과 같이 계산된다.

$Z'=\sum_{v\in V}\exp\bigg(\mathbf{e}^T_v\bigg(\sum^n_{k=1}\mathbf{e}^T_{w^{i-k}}+\sum^n_{k=1}\mathbf{e}^T_{w^{i+k}}\bigg)\bigg)$

앞서봤던 neural language 모델과 굉장히 비슷하다는 것을 볼 수 있다. 이러한 조건부 확률은 얕은(shallow) neral network와 같다. input이 context 단어들인 한개의 linear한 은닉층을 가지고, output이 중심 단어에 대한 조건부 확률이 되는 것이다. 이 network를 그림으로 표현하면 다음과 같다.

우리는 이미 전체 문장에 대한 확률 $p(w^1,…,w^T)$을 직접 계산하는 것은 $Z$ 게산량이 많아 어렵다는 것을 알고 있다. 다행이 상대적으로 계산이 쉬운 조건부 확률을 계산하는 것을 확인했다. 전자의 경우는 log-likelihood를 최대화하는 것과 같고, 후자의 경우에는 pseudo-likelihood를 최대화 하는 것과 같다.

따라서 MRF-LM의 Pseudo-likelihood는 다음과 같다.

$\log \text{PL}=\sum^T_{i=1}\log p(w^i|w^{i-n},...,w^{i-1},w^{i+1},...,w^{i+n})$

위의 Pseudo-likelihood를 최대화 하는 것은 위의 그림의 network를 학습하는 것과 동일하다. 즉 주변 단어에 대한 중심 단어의 확률을 높이는 것이다.

위의 식을 잘 계산한다해도 아직 전체 문장에 대한 확률을 계산하는 좋은 방법은 없다. 어떤 특정한 상황에서는 pseudo-likelihood 값이 maximum likelihood 값에 수렴하기도 하지만 그렇다고 조건부 확률들의 곱이 전체 문장의 확률을 대체할 수 있는 것은 아니다. 그렇지만 다행이도 MRF-LM 모델을 사용한다면 pseudo-probability도 다른 문장의 점수를 줄 수 있다. 앞서서 우리가 처음 neural language 모델에 대해 처음 봤을 떄는 각 단어의 조건부 확률을 첫 단어부터 마지막까지 곱하면 주어진 문장의 확률을 구할 수 있다는 내용과는 대조적이다. 이러한 결과가 MRF-LM을 laguage 모델로 잘 사용하지 않는 이유 중 하나일 것이다. 하지만 이 단원에서 처음으로 이 복잡한 모델을 설명한 이유가 있다.

Continuous bag-of-words(CBOW)에서 처음 소개된 이러한 접근법은 흥미로운 특징을 발견했다. CBOW 모델의 한 부분인 학습된 단어 임베딩 행렬 $\mathbf{E}$가 단어의 잠재 구조를 매우 잘 반영한다는 것이다. 결국 이 모델은 최근 자연어 처리 분야에서 가장 각광받는 기술이 되었다. 다음 장에서 이 부분에 대해 더욱 다뤄볼 것이다.

Skip-Gram and Implicit Matrix Factorization

Markov에 의해 CBOW모델 뿐 아니라 skip-gram이라 불리는 모델 또한 소개되었다. skip-gram모델은 CBOW의 반대되는 모델이라 생각하면 된다. 주변 $2n$개의 단어에 의해 중심단어를 예측한는 CBOW와는 반대로 skip-gram의 경우는 중심 단어를 통해 주변 $2n$개의 단어를 예측하는 모델이다. 그리고 실제로 두 모델에 의해 생성된 단어 vector 중 skip-gram에 의해 만들어진 vector가 좀 더 효과가 좋다는 것이 결론이다. 물론 좋은 단어 vector를 판단하는 것은 논란의 여지가 있는 부분이지만 많은 “intrinsic”한 평가에서 skip-gram 모델이 더 좋은 것으로 보여진다. 위 기술들을 만든 Markov는 negative sampling으로 skip-gram모델을 학습시키는 것은 positive point-wise mutual information matrix(PPMI) 을 2 lower-dimensional matrix로 만드는 것과 동일하다고 한다.

5.4.3 Semi-Supervised Learning with Pretrained Word Embeddings

위에 나온 n-gram language model, neural language modellanguage model, continuous bag-of-words 모델들에서 중요한 점은 모든 모델이 unsupervised 하다는 점이다. unsupervised가 중요한 이유는 각 데이터에 대해 label을 필요로 하지 않는다. 이러한 점이 다른 modeling에 비해 statical한 modeling이 language modeling에 더욱 적합한 이유이다. 그리고 label이 필요없기 때문에 학습 시킬 수 있는 데이터는 무한히 많이 존재한다는 장점이 있다. 그리고 소개된 modeling중에 embedding된 word vector는 자연어 처리 분야에서 최근에 대부분이 사용하게 됬다.

하나의 예를 들어보자. 영어 단어를 긍정과 부정으로 나누는 문제이다. 예를 들어 “happy”는 긍정이고, “sad”는 부정으로 분류하는 문제이다. 긍정 부정 각각 1개씩 총 2개의 데이터만 존재한다고 하자. 어떻게 classifier를 만들 것인가?

우선 두 가지 이슈가 있다. 먼저 input을 어떻게 표현할지를 선택해야한다. 기본적으로는 one-hot vector로 input을 넣고 output을 위해 softmax layer를 사용할 것이다. 그러나 여기에도 문제가 아직 남아있다. 학습을 위한 데이터가 오직 2개 뿐이라는 것이다.

이러한 문제를 해결하기 위해 한가지 가정을 한다. 비슷한 input값은 비슷한 감정을 가진다는 가정을 한다. 이러한 가정은 semi-supervised 학습의 핵심이다. 이것을 높은 차원의 데이터를 효과적으로 저차원으로 옮기는 것이다. 이러한 과정을 통해 저차원의 데이터를 가지고 좋은 모델을 만들 수 있다.

이제 사전 학습된 단어 벡터를 사용한다고 하자. 그러면 다음과 같은 nearest neighbour(NN) 분류기를 만들 수 있다.

$NN(w)= \begin{cases} \text{positive,~~~~if~}\cos(\mathbf{e}_w,\mathbf{e}_{\text{happy}})>\cos(\mathbf{e}_w,\mathbf{e}_{\text{bad}})\\ \text{negative,~~~otherwise} \end{cases}$

여기서 $\cos(\cdot ,\cdot )$ 은 아래의 식인 cosine similarity를 의미한다.

$\cos(\mathbf{e}_i,\mathbf{e}_j)=\frac{\mathbf{e}_i^T\mathbf{e}_j}{\|\mathbf{e}_i\|\|\mathbf{e}_j\|}$

이 연산을 통해 우리는 ‘유사도’라는 성질을 이용한다. 이 방법을 통해 사전 학습된 단어 벡터는 대부분의 문제를 해결할 수 있지만, 경우에 따라 사용하는데 주의해야 한다. 이러한 단어 벡터는 어떤 objective function을 최대화 하면서 만들어진다. 실제로 유사도에는 다양한 측면에서 적용되지만 이렇게 학습된 단어 벡터는 몇 개의 특정한 측면의 유사도만 적용된다. 몇 가지 측면은 학습할 때의 데이터에 따라 달라진다.

예를 들어 “happy”, “sad”, “angry”와 같은 감정을 표현하는 단어를 continuous bag-of-words의 문맥에서 생각해보자. 이러한 감정을 표현하는 단어들은 “feel”이라는 단어와 같이 등장하는 경우가 많다. 따라서 위와 같은 단어들은 “feel”이후에 등장할 확률이 높도록 학습될 것이다. 즉 각각의 감정을 표현하는 단어가 비슷한 벡터 공간에 존재할 수 있다. 그러나 감정 분석적인 측면에서는 이러한 표현은 좋지 않다.

만약 적은 데이터로 언어와 관련된 문제를 해결하려 한다면, 사전 학습된 벡터를 사용하는 것을 고려해보도록 한다. 그러나 해결해야 하는 문제를 고려해서 학습된 벡터를 사용해야 한다.

5.5 Recurrent Laguage Model

Neural Language modeling은 일반적인 n-gram모델의 일반화 부족(lack of generalization)문제를 해결한다. 하지만 여전히 n번째 단어는 이전 n-1 개의 단어를 보는 Markov 속성을 가정한다. 즉 이전에 들었던 예시인 “In Korea, more than half of all the residents speak Korea”이라는 문장에서 처럼 마지막 단어에 대한 조건부 확률 분포는 문장의 2번째단어, 즉 10개 전인 단어에 대해 추정하는 것이 효율적이다.

4.1.4 단원에서 배웠던 것을 다시 생각해보자. 우리는 가변 길이의 문장을 읽고 가변 길이의 output을 만드는 recurrent neural network에 대해 배웠다. POS-tagging 을 하는 이전에 봤던 예시를 다시 보자. input은 다음과 같다.

$x=(\text{Children},~\text{eat},~\text{sweet},~\text{candy})$

그리고 target output 은 품사의 sequence이다.

$y=(\text{noun},~\text{verb},~\text{adjective},~\text{noun})$

각각의 예측되는 tag들이 서로 독립이라는 가정을 제거하기 위해 각 step의 예측 값인 $Y_t$ 의 값이 다음 step의 input 값인 $X_{t+1}$ 과 함께 다음 step에서 계산된다.

전체 문장 확률을 계산하는 과정에서의 단일 단어에 대한 확률계산하는 것을 생각해보자.($a$)

$p(w^1,w^2,...w^T)=\prod^T_{t=1}\underbrace{p(w^t|w^1,...,w^{t-1})}_{(a)}$

이때까지 배웠던 내용을 토대로 우리는 input $(w^1,...,w^{t-1})$ 에 대해 위의 조건부 확률($a$)을 neural network를 통해 구할 수 있다.(앞서 배운 것과 input이 가변길이라는 점만 다르고 나머지는 모두 같다)

하지만 여기서는 가변 길이의 input 문장을 summarizing/memorizing 할 수 있는 recurrent neural network를 사용해 본다. recurrent neural network는 input 문장 (w^1,…,w^{t-1})를 메모리 상태인 $\mathbf{h}^{t-1}$ 로 summarizing한다.

$\mathbf{h}^{t'}= \begin{cases} \begin{matrix} 0,&\text{if~}t'=0\\ f(\mathbf{e}_{w^{t'}},\mathbf{h}^{t'-1}),&\text{otherwise} \end{matrix} \end{cases}$

여기서 $t'$ 은 $0$ 부터 $t-1$ 까지 계산된다. $f$ 는 이전에 배웠던 recurrent 함수 중 선택해서 사용하면 된다.(GRU, LSTM) 그리고 $\mathbf{e}_{w’}$은 단어 $w’$의 벡터 이다.

마지막 과정은 어떻게 해야 하는 지 기억 할 것이다.

$\mu = \text{softmax}(\mathbf{V}\mathbf{h}^{t-1})$

이 계산결과로 나온 $\mu$는 모든 단어에 대한 확률 벡터가 된다. 이 과정에서 input 문장을 단 한번만 읽어서 계산한다. 즉 각 setp에서 단어 하나만 읽어서 update한다.

이러한 lagugage model을 recurrent neural netwrok language model(RNN-LM)(b)이라 부른다.

(a) A Recurrent neural network, (b) Recurrent neural network language model

5.6 How do n-gram language model, neural language model and RNN-LM compare?

마지막으로 이제 하나의 질문이 남았다. 이 때까지 배운 language model 중 어떤 model을 실전에서 선택해서 사용해야 하는 가? 이다. 우선 이 질문에 대답하기 위해 먼저 일반적으로 language model들을 평가하는 방법에 대해 얘기해 보자.

가장 일반적으로 많이 사용하는 측정법은 perplexity 이다. model $\mu$에 대해 perplexity PPL은 다음과 같이 계산한다.

$\text{PPL} = b^{-\frac{1}{N}\sum^N_{n=1}\log_b p_\mu(w_n|w_{<n}) }$

$N$은 validation/test 말뭉치의 모든 단어의 수 이고, $b$는 상수로 보통 2 또는 10의 값을 사용한다.

이 값이 의미하는 것은 무었일까? 이 값에 대해 정보이론을 바탕으로 자세히 설명된 내용이 있지만 이 값을 전부 우리가 이해할 필요는 없다.

exponential 함수는 단조 증가 함수이므로 위 함수에서 $log_b$ 대신 자연 로그를 사용하더라도 괜찮다.(b>1 이라 가정한다)

$-\frac{1}{N}\sum^N_{n=1}\log p_\mu(w_n|w_{<n})$

이 함수는 cost 함수 혹은 negative log-likelihood와 매우 유사하다. summation 안의 항에 대해서만 보자.

$\log p_\mu(w_n|w_{<n})$

이 값은 language model $\mu$이 주어진 이전 단어에 대해 정확한 현재 단어를 예측하면 높은 값을 가진다. (log는 단조 증가이기 떄문)

요약하면 perplexity를 측정하는 것은 language model이 test/validate 말뭉치에 대해 정확히 예측한 평균치 값을 의미한다. 따라서 더 나은 language model은 적은 perplexity 값은 갖는 model이다.

이제 우리는 language model을 비교할 준비가 되었다. 다음의 3가지의 model을 생각해보자.

count-based n-gram language model
neural n-gram language model
recurrent neural netowrk language model

이렇게 여러 모델을 비교할 때 가장 큰 어려움은 제어하기 어려운 요소들이다. 예를들면 다음과 같다.

Language
Genre/Topic of training, validation and test corpora
Size of a training corpus
Size of a language model

이러한 어려움 때문에 모델들의 비교는 종종 특정한 downstream application에서 진행한다. 이런 downstream application은 가능한 크기, 말뭉치 target language, language model의 size등 많은 제약을 가진다. 예를 들어 Pragmatic neural language modelling in machine translation 에서는 n-gram과 neural language model을 다양한 근사 기술들을 통해 기계 번역 분야에서 비교했다. 그리고 From feedforward to recurrent lstm neural networks for language modeling에서는 저자는 세개의 language model을 자동 음성 인식분야에서 비교했다.

먼저 From feedforward to recurrent lstm neural networks for language modeling의 결과를 살펴보자.

결과를 보면 RNN-LM이 일반적인 neural language model을 사용하는 것과 비교해서 효과적이다. 특지 LSTM을 사용할 때는 다른 모델에 비해 성능 향상이 눈에 띈다. 그리고 같은 모델 안에서도 model의 크기를 키우면 성능이 좋아진느 것도 볼 수 있다. 그리고 perplexity도 더 큰 language 모델이 적은 값을 가졌고 여러 모델 중에서는 RNN-LM이 적은 값을 가졌다.

이러한 결과를 통해 보면, neural model 또는 recurrent model이 language modeling 할 때 좋은 후보가 될 수 있다. 그리고 많은 논문에서의 관찰을 통해 보면 count-based n-gram과 neural, recurrent 모델들을 같이 사용할 때 좋은 결과를 보여줬다. 즉 hybird한 model에서 각 model이 잠재적인 언어 구조를 잘 잡아 냈다는 것이다. 그러나 아직 어떻게 다른 구조를 잡아내는 지에 대해 밝혀지진 않았다.

파라미터 최적화

2018-07-02T04:47:35+00:00

파라미터 최적화 (Parameter Optimization)

딥러닝 학습의 기본은 파라미터들을 최적의 값으로 빠르고 정확하게 수렴하는 것을 목적으로 한다. 파라미터를 최적화 하는 방법에는 여러 방법들이 있다. Gradient Descent를 기반으로한 방법들, 모멘텀 방식을 도입한 학습 방법 그 외에도 AdaGrad, RMSProp, Adam까지 여러 방법들이 존재한다. 최적화 방법 선택에 따라 최적화까지의 시간에 차이는 매우 크게 난다. 따라서 최적화 방법을 잘 선택하는 것이 매우 중요한데, 그럼 방법들에 대해서 하나씩 알아보도록 한다.

1. Gradient Descent기반 방식들

파라미터 최적화 방법으로 가장 널리 알려진 방법은 그라디언트 디센트(Gradient Descent)방식이다. 이 방법은 현재의 미분값을 기반으로해서 파라미터가 업데이트 해야할 방향과 크기를 설정합니다. 업데이트 수식을 아래와 같습니다.

$\theta \leftarrow \theta -\eta\frac{\partial L}{\partial \theta}$

여기서 $\theta$는 학습할 파라미터를 뜻하고, $\eta$는 미분값을 기준으로 update할 시 어느정도의 크기로 학습할 것인가를 나타내는 학습률(Learning rate)을 뜻한다. $L$은 모델의 손실함수(Cost Function)을 뜻한다. 따라서 위식에 따르면, 파라미터를 파라미터로 손실함수를 미분한 값 반대방향으로 $\eta\frac{\partial L}{\partial \theta}$크기만큼 이동하라는 것을 뜻한다.

여기까지가 Gradient Descent의 기본에 대해 설명한 것이고, 이 방법을 기반으로 한 방법들에 대해서 하나씩 살펴보도록 하자.

1-1)Batch Gradient Descent

Batch Gradient Descent 방식이란, 모든 데이터셋을 하나의 batch로 보고 전체의 미분값을 평균하여 1에폭동안 update를 딱 한번 수행하는 방식이다. 속도가 느리다는 단점이 있지만, 최적값을 찾을 수 있다는 장점이 있다.

for i in range(nb_epochs):
    params_grad = evaluate_gradient(loss_function, data, params)
    params = params - learning_rate * params_grad

1-2)Stochastic Gradient Descent(SGD)

확률적 경사하강법인 Stocchastic Gradient Descent(SGD)는 각 iteration에서 하나의 example만을 뽑아서 학습시키는 방법이다. 엄밀하게 SGD는 하나의 data만을 뽑아서 학습시키는 방법이지만, 랜덤하게 n개의 데이터를 뽑아 update시키는 방법인 MGD(Mini-Batch Gradient Descent)방식 대신 SGD로 표현해서 사용하기도 합니다. SGD사용은 속도를 훨씬 빠르게 한다는 장점이있고, 아래와 같은 특징들이 있다.

for-loop을 돌기전 데이터 셋을 랜덤하게 Suffle할 필요가 있다.

SGD방식은 BGD방식에 비해 최적화로 가는 과정에서 Noise가 많이 발생할 수 있다.

for i in range(nb_epochs):
  np.random.shuffle(data)
  for iter in range(start_iter, num_iter):
  	params_grad = evaluate_gradient(loss_function, data[0], params)
  	params = params - learning_rate * params_grad

1-3)Mini-Batch Gradient Descent

미니배치 방식의 Gradient Descent 방식은 일정크기 n만큼의 데이터에 대해서 미분값을 평균하여 update하는 방식이다. SGD에 비해 안정적이며, 속도도 BGD에 비해 빨라 대부분 많이 사용하는 방식이다.

for i in range(nb_epochs):
    np.random.shuffle(data)
    for batch in get_batches(data, batch_size=50):
    	params_grad = evaluate_gradient(loss_function, batch, params)
    	params = params - learning_rate * params_grad

2. Momentum

2-1) Momentum

모멘텀이란 물리학 용어로 물체의 속도와 질량에 관련된 운동량을 뜻한다. 아래 그림을 보자 왼쪽 그림의 경우 위 아래 방향으로는 계속해서 반복되는 운동을 하는 것을 볼 수 있는데, 오른쪽으로는 한방향으로만 움직인다. 이러한 경우 오른쪽 방향으로의 운동량이 계속해서 누적된다는 것을 확인 할 수 있다. 따라서 Momentum 방식을 따르면 오른쪽 그림과 같이 위 아래 반복적인 움직임은 여전히 보여주지만 오른쪽으로 지속적인 움직임이 누적되서 더욱 빠르게 최적화가 되는 것을 확인할 수 있다.

모멘텀의 수식은 다음과 같다.

$v\leftarrow \mu v-\eta \frac { \partial L }{ \partial \theta }$ $\theta \leftarrow \theta +v$

GD방식과는 달리 새로운 하이퍼 파라미터 $\mu$와 변수인 $v$가 새롭게 추가되었다. 위 수식을 보면 위의 모멘텀을 적용한 학습 경과가 이해될 것이다. 오른쪽 방향으로의 미분값은 계속해서 $v$에 더해져서 더욱 큰 값을 갖게 되어 빠르게 이동할 수 있는 것이다.

param_grad = evaluate_gradient(loss_function, data, params)
v = mu * v - learning_rate * param_grad
param = v + param

2-2) Nesterov 모멘텀 (Nesterov Momentum)

Nesterov Momentum 방식은 최근 많은 주목을 받은 방식으로, Momentum과는 약간 다르다. Convex function에서는 이 함수가 이론적으로 최적화에 유리하며, 일반적으로도 Momentum 방식보다는 좋다는 의견이 있다.

Nestrov 모멘텀의 방식은 모멘텀방식에서 현재위치인 $\theta$에서 미분값을 구하는 것이 아니라, 우리가 이동할 위치인 $\theta+\mu v$의 위치에서의 미분값을 계산하는 것이 모멘텀 방식과의 다른점이다. 그림을 통해 살펴보자. momentum방식에서는 빨간점에서의 미분값을 계산해 update를 시켰으나, Nestrov 방식에서는 초록색 벡터의 끝점에서 미분값을 계산해 update를 시킨다는 것을 의미한다. 아래 식을 보면 조금 더 명확하게 이해될 것이다.

$v_{t+1}=\mu v_{t}-\eta g(\theta_{t}+\mu v_{t})$ $\theta_{t+1}=\theta_{t}+v_{t+1}$

params_ahead = params + mu * v
params_grad_ahead = evaluate_gradient(loss_function, data, params_ahead)
v = mu * v - learning_rate * params_grad_ahead
params = v + params

3. Per-parameter adaptive learning rate 방법들

이때까지의 파라미터 최적화 방법들에서는 모든 파라미터에 대해 똑같은 학습 속도를 적용 하였다. 그러나 Per-parameter adaptive learning rate 방법들에서는 각 파라미터에 대해 adaptive한 학습 속도를 적용한다.

3-1) AdaGrad

AdaGra는 Adaptive gradient based 방식으로 Duchi et al.에서 처음으로 소개했다. AdaGrad에서는 이전 update에서 update가 많이 된 파라미터들에 대해서는 학습량을 줄이는 방법을 사용한다. 수식은 아래와 같다.

$h\leftarrow h+\frac { \partial L }{ \partial \theta } \odot \frac { \partial L }{ \partial \theta }$ $\theta \leftarrow \theta -\frac { \eta }{ \sqrt { h } } \frac { \partial L }{ \partial \theta }$

params_grad = evaluate_gradient(loss_function, data, params)
h = h + params_grad**2
params = params - learning_rate / (np.sqrt(h) + eps) * params_grad

코드를 확인해보면, 수식과는 약간 다른점을 확인 할 수 있다. 아래 식의 $\sqrt{h}$ 값에 eps라는 변수가 더해져 있다. 이 값은 $h$가 0이 되거나 0에 너무 가깝게 되서 전체값이 너무 커져버리는 상황을 방지하기위한 변수로 주로 1e-4에서 1e-8정도의 값을 준다.

하지만 이 방법은 지나치게 learning rate을 낮추는 경향이 있어 deep learning model에 적용 시 잘 학습이 되지 않는 경향이 있어 자주 사용하지 않는다.

3-2) RMSProp

AdaGrad에서는 $L$을 parameter로 미분한 값을 제곱한 값을 계속 더한 것을 update시 미분값에 나눠준다. 이러한 과정을 계속해서 반복하면, 최종적으로 upadate 값이 0에 수렴해 학습이 불가능해진다. RMSProp은 이러한 문제를 개선한 방법으로 지수 이동 평균(Exponential moving average)을 사용하였다.

지수 이동 평균이란 과거의 모든 기간을 계산 대상으로 하며, 최근의 데이터에 더 높은 가중치를 부여한는 일종의 가중 이동 평균 방법이다.

params_grad = evaluate_gradient(loss_function, data, params)
h = decay_rate * h + (1 - decay_rate) * params_grad**2
params = params - learning_rate / (np.sqrt(h) + eps) * params_grad

위 코드에서 decay_rate는 hyper-parameter로 사용자가 직접 정해야 하며, 주로 0.9, 0.99, 0.999중 하나를 선택해 사용한다.

3-3) Adam

모멘텀 기법은 운동량에 착안해서 만든 방법이고, RMSProp은 파라미터 개별마다 Adaptive한 학습방식이다. Adam 은 이 두방법을 합친 방법이라 할 수 있다. 실전에서 Adam은 가장 기본적으로 사용되는 방법이고, 성능이 좋아 많이 사용하는 방법이다.

수식은 다음과 같다.

$m_t = \beta_1 m_{t-1} + (1-\beta_1)\nabla_\theta J(\theta)$ $v_t = \beta_2 v_{t-1} + (1-\beta_2)(\nabla_\theta J(\theta))^2$ $\hat{m_t} = \frac{m_t}{1-\beta_1^t}$ $\hat{v_t} = \frac{v_t}{1-\beta_2^t}$ $\theta = \theta - \frac{\eta}{\sqrt{\hat{v_t}+\epsilon}}\hat{m_t}$

사용자가 직접 설정해야 할 Hyper parameter는 $\beta_{1}$과 $\beta_{2}$, 그리고 $\epsilon$으로 3가지다. 보통 $\beta_{1}=0.9$, $\beta_{2}=0.999$, $\epsilon$ 값으로는 $1e-8$ 로 설정한다.

파라미터 최적화 방법 비교

출처

가중치 초기화 (Weight Initialization)

2018-07-01T04:47:35+00:00

초기 가중치 설정 (weight initialization)

딥러닝 학습에 있어 초기 가중치 설정은 매우 중요한 역활을 한다. 가중치를 잘못 설정할 경우 기울기 소실 문제나 표현력의 한계를 갖는 등 여러 문제를 야기하게 된다. 또한 딥러닝의 학습의 문제가 non-convex 이기 때문에 초기값을 잘못 설정할 경우 local minimum에 수렴할 가능성이 커지게 된다.

초기값 설정을 잘못해 문제가 발생하는 경우들을 살펴보자.

1) 초기값을 모두 0으로 설정한 경우

만약 데이터를 평균 0정도로 정규화시킨다면, 가중치를 0으로 초기화 시킨다는 생각은 꽤 합리적으로 보일 수 있다. 그러나 실제로 0으로 가중치를 초기화 한다면 모든 뉴런들이 같은 값을 나타낼 것이고, 역전파 과정에서 각 가중치의 update가 동일하게 이뤄질 것이다. 이러한 update는 학습을 진행 해도 계속해서 발생할 것이며, 결국 제대로 학습하기 어려울 것이다. 또한 이러한 동일한 update는 여러 층으로 나누는 의미를 상쇄시킨다.

2) 활성화 함수로 sigmoid 사용시 정규 분포 사용

지난 포스트에서 확인했듯이 sigmoid함수는 input의 절대값이 조금이라도 커지게 되면 미분값이 소실되는 문제가 발생한다는 것을 확인했다.(Post 참고) 이 경우에 평균 0이고 표준편차가 1인 정규분포를 따르도록 가중치를 랜덤하게 초기화 한다고 가정하자. 이 경우에는 표준편차가 크기 때문에 학습을 반복할 수록 가중치 값들이 0,1 로 치우치는 문제 발생한다.(Gradient Vanishing) 이 경우 물론 Activation Function을 바꿈으로써 해결 할 수도 있겠지만, 가중치 초기화를 잘 설정함으로써도 어느정도 해결할 수 있다.

3) 2의 case에서 표준편차를 줄였을 경우

2의 문제를 확인하고 표준편차가 커 $|x|$값이 커지면서 기울기가 소실되는 문제를 확인했기 때문에, 표준편차를 줄여서 $|x|$값을 줄이려는 생각을 가지고 표준편차를 0.01로 설정한다고 가정하자. 이 경우에는 또다른 문제가 발생한다.
이렇게 표준편차를 적게 하면 층이 깊어질 수록 가중치 값들이 중간 값인 0.5 부근에 몰리는 문제를 확인할 수 있을 것이다.

따라서 이렇게 가중치를 설정하는 것만으로도 학습의 큰영향을 끼친다는 것을 확인할 수 있었다. 그렇다면 더 나은 학습을 위해 가중치를 초기화하는 여러 방법들에 대해서 알아보도록 한다.

1. LeCun Initialization

LeCun은 지난번 소개한 LeNet의 창시자이며, CNN을 세상에 도입한 사람이라 할 수 있다. 1998년 LeCun은 효과적인 역전파를 위한 논문에서 초기화 방법에 대해서 소개했는데 정규분포를 따르는 방법과 균등분포를 따르는 두가지 방법에 대해서 소개하였다.(LeCun 98, Efficient Backprop)

LeCun Normal Initialization

$W\sim N({ 0 }, Var(W))$ $Var(W)=\sqrt{\frac { 1 }{ n_{ in }} }$

($n_{in}$ : 이전 layer(input)의 노드 수)

LeCun Uniform Initialization

$W\sim U(- \sqrt{\frac { 1 }{ { n }_{ in } } } , \space\space + \sqrt{\frac { 1 }{ { n }_{ in } } } )$

($n_{in}$ : 이전 layer(input)의 노드 수)

2. Xavier Initialization

Xavier Initialization 혹은 Glorot Initialization라고도 불리는 초기화 방법은 이전 노드와 다음 노드의 개수에 의존하는 방법이다. Uniform 분포를 따르는 방법과 Normal분포를 따르는 두가지 방법이 사용된다.(Glorot & Bengio, AISTATS 2010)

구조는 LeCun의 초기화 방법과 유사하지만 다음 층의 노드 수도 사용하고, 많은 연구를 통해 가장 최적화된 상수값 또한 찾아냈다.

Xavier Normal Initialization

$W\sim N({ 0 }, Var(W))$ $Var(W)=\sqrt{\frac { 2 }{ { n }_{ in }+{ n }_{ out } } }$

($n_{in}$ : 이전 layer(input)의 노드 수, $n_{out}$ : 다음 layer의 노드 수)

Xavier Uniform Initialization

$W\sim U(- \sqrt{\frac { 6 }{ { n }_{ in }+{ n }_{ out } } } , \space\space + \sqrt{\frac { 6 }{ { n }_{ in }+{ n }_{ out } } } )$

($n_{in}$ : 이전 layer(input)의 노드 수, $n_{out}$ : 다음 layer의 노드 수)

Xaiver함수는 비선형함수(ex. sigmoid, tanh)에서 효과적인 결과를 보여준다. 하지만 ReLU함수에서 사용 시 출력 값이 0으로 수렴하게 되는 현상을 확인 할 수 있다. 따라서 ReLU함수에는 또 다른 초기화 방법을 사용해야 한다.

3.He Initialization

ReLU를 활성화 함수로 사용 시 Xavier 초기값 설정이 비효율적인 결과를 보이는 것을 확인했는데, 이런 경우 사용하는 초기화 방법을 He initialization이라고 한다. 이 방법 또한 정규분포와 균등분포 두가지 방법이 사용된다.(He et al. ,2015)

He Normal Initialization

$W\sim N({ 0 }, Var(W))$ $Var(W)=\sqrt{\frac { 2 }{ { n }_{ in } } }$

($n_{in}$ : 이전 layer(input)의 노드 수)

He Uniform Initialization

$W\sim U(- \sqrt{\frac { 6 }{ { n }_{ in } } } , \space\space + \sqrt{\frac { 6 }{ { n }_{ in } } } )$

($n_{in}$ : 이전 layer(input)의 노드 수)

Bias 초기화

가중치 초기화 뿐만 아니라 편향(bias) 초기값 또한 초기값 설정 또한 중요하다.
보통의 경우에는 Bias는 0으로 초기화 하는 것이 일반적이다. ReLU의 경우 0.01과 같은 작은 값으로 $b$를 초기화 하는 것이 좋다는 보고도 있지만 모든 경우는 아니라 일반적으로는 0으로 초기화 하는 것이 효율적이다.

Conclusion

다양한 종류의 초기화 방법에 대해서 알아 보았다. 초기값 설정이 학습과정에 매우 큰 영향을 끼칠 수 있기 때문에 초기화 방법 또한 신중히 선택해야 한다.

Sigmoid, tanh 경우 Xavier 초기화 방법이 효율적이다.
ReLU계의 활성화 함수 사용 시 He 초기화 방법이 효율적이다.
최근의 대부분의 모델에서는 He초기화를 주로 선택한다.

마지막으로, 대부분의 초기화 방법이 Normal Distribution과 Uniform Distribution을 따르는 두가지 방법이 있는데 이에대한 선택 기준에 대해서는 명확한 것이 없다. 하지만 He의 논문의 말을 인용하면,

최근의 Deep CNN 모델들은 주로 Gaussian Distribution을 따르는 가중치 초기화 방법을 사용한다.

따라서 Deep CNN의 경우 보통의 Gaussian 초기화 방법을 사용해 볼 수 있다.하지만 여러 초기화 방법들을 테스트하며 사용하는 것이 가장 좋은 방법일 것이다.

딥러닝에서 사용하는 활성화함수

2018-07-01T04:47:35+00:00

딥러닝에서 사용하는 활성화 함수

딥러닝 네트워크에서는 노드에 들어오는 값들에 대해 곧바로 다음 레이어로 전달하지 않고 주로 비선형 함수를 통과시킨 후 전달한다. 이때 사용하는 함수를 활성화 함수(Activation Function) 이라 부른다.

여기서 주로 비선형 함수를 사용하는 이유는 선형함수를 사용할 시 층을 깊게 하는 의미가 줄어들기 때문이다.

선형함수인 h(x)=cx를 활성화함수로 사용한 3층 네트워크를 떠올려 보세요. 이를 식으로 나타내면 y(x)=h(h(h(x)))가 됩니다. 이는 실은 y(x)=ax와 똑같은 식입니다. a=c3이라고만 하면 끝이죠. 즉, 은닉층이 없는 네트워크로 표현할 수 있습니다. 뉴럴네트워크에서 층을 쌓는 혜택을 얻고 싶다면 활성화함수로는 반드시 비선형 함수를 사용해야 합니다. - 밑바닥부터 시작하는 딥러닝 -

이번 포스트에서는 딥러닝에서 사용되는 활성화 함수들에 대해서 하나씩 알아보도록한다.

1. 시그모이드 함수 (Sigmoid)

시그모이드 함수는 Logistic 함수라 불리기도한다. 선형인 멀티퍼셉트론에서 비선형 값을 얻기 위해 사용하기 시작했다. 함수는 아래와 같이 구성된다.

$\sigma(x)=\frac{1}{ 1+e^{-x} }$ $\sigma'(x)=\sigma(x)(1-\sigma(x))$

시그모이드 함수와 시그모이드 함수의 미분함수를 그래프로 나타내면

sigmoid에 대해 특징을 살펴보자.

우선 함수값이 (0, 1)로 제한된다.
중간 값은 $\frac{1}{2}$이다.
매우 큰 값을 가지면 함수값은 거의 1이며, 매우 작은 값을 가지면 거의 0이다.

이러한 특징을 가지는 sigmoid는 신경망 초기에는 많이 사용되었지만, 최근에는 아래의 단점들 때문에 사용하지 않는다.

Gradient Vanishing 현상이 발생한다. 미분함수에 대해 $x=0$에서 최대값 $\frac{1}{4}$ 을 가지고, input값이 일정이상 올라가면 미분값이 거의 0에 수렴하게된다. 이는 $|x|$값이 커질 수록 Gradient Backpropagation시 미분값이 소실될 가능성이 크다.
함수값 중심이 0이 아니다. 함수값 중심이 0이 아니라 학습이 느려질 수 있다. 그 이유를 알아보면. 만약 모든 $x$값들이 같은 부호(ex. for all $x$ is positive) 라고 가정하고 아래의 파라미터 $w$에 대한 미분함수식을 살펴보자. $\frac{\partial{L}}{\partial{w}}=\frac{\partial{L}}{\partial{a}}\frac{\partial{a}}{\partial{w}}$ 그리고 $\frac{\partial{a}}{\partial{w}}=x$이기 때문에, $\frac{\partial{L}}{\partial{w}}=\frac{\partial{L}}{\partial{a}}x$ 이다. 위 식에서 모든 $x$가 양수라면 결국 $\frac{\partial{L}}{\partial{w}}$는 $\frac{\partial{L}}{\partial{a}}$ 부호에 의해 결정된다. 따라서 한 노드에 대해 모든 파라미터$w$의 미분값은 모두 같은 부호를 같게된다. 따라서 같은 방향으로 update되는데 이러한 과정은 학습을 zigzag 형태로 만들어 느리게 만드는 원인이 된다.
exp 함수 사용시 비용이 크다.

이러한 단점들 때문에 초기에는 자주 사용하는 활성화 함수였지만, 최근에는 자주 사용하지 않게 되었다.

2. $tanh$ 함수, (Hyperbolic tangent function)

하이퍼볼릭탄젠트란 쌍곡선 함수중 하나이다.

쌍곡선 함수 : 쌍곡선 함수란 삼각함수와 유사한 성질을 가지고, 표준 쌍곡선을 매개변수로 표시할 때 나오는 함수이다.

하이퍼볼릭탄젠트 함수는 시그모이드 함수를 transformation해서 얻을 수 있다.

-1 vertical shift & 1/2 horizontal squeeze & 2 vertical stretch

함수는 다음과 같이 정의된다.

$tanh(x)= 2\sigma(2x)-1$ $tanh(x) =\frac { { e }^{ x }-{ e }^{ -x } }{ { e }^{ x }+{ e }^{ -x } }$ $tanh'(x)=1-tanh^2(x)$

tanh 함수는 함수의 중심값을 0으로 옮겨 sigmoid의 최적화 과정이 느려지는 문제를 해결했다.
하지만 미분함수에 대해 일정값 이상 커질시 미분값이 소실되는 gradient vanishing 문제는 여전히 남아있다.

3. ReLU 함수 (Rectified Linear Unit)

ReLu함수는 최근 가장 많이 사용되는 활성화 함수이다. 함수는 아래와 같이 정의된다.

$f(x)=max(0, x)$

ReLU함수의 특징을 살펴보자.

$x>0$ 이면 기울기가 1인 직선이고, $x<0$이면 함수값이 0이된다.
sigmoid, tanh 함수와 비교시 학습이 훨씬 빨라진다.
연산 비용이 크지않고, 구현이 매우 간단하다.
$x<0$인 값들에 대해서는 기울기가 0이기 때문에 뉴런이 죽을 수 있는 단점이 존재한다.

4. Leakly ReLU

leakly ReLU는 ReLU의 뉴런이 죽는(“Dying ReLu”)현상을 해결하기위해 나온 함수이다. 함수도 매우 간단한 형태로 다음과 같다.

$f(x)=max(0.01x,x)$

위의 식에서 0.01대신 다른 매우 작은 값 사용 가능하다.

Leakly ReLU는 음수의 $x$값에 대해 미분값이 0되지 않는다는 점을 제외하면 ReLU와 같은 특성을 가진다.

5. PReLU

$f(x)=max(\alpha x,x)$

Leakly ReLU와 거의 유사하지만 새로운 파라미터 $\alpha$ 를 추가하여 $x<0$에서 기울기를 학습할 수 있게 하였다.

6. Exponential Linear Unit(ELU)

ELU는 비교적 가장 최근에 나온 함수이다. Clevert et al. ,2015

$f(x)=x\quad if\quad x>0$ $f(x)=\alpha ({ e }^{ x }-1)\quad if\quad x\le 0$

ELU 의 특징은 다음과 같다.

ReLU의 모든 장점을 포함한다.
“Dying ReLU” 문제를 해결했다.
출력값이 거의 zero-centered에 가깝다
일반적인 ReLU와 달리 exp함수를 계산하는 비용이 발생한다.

7. Maxout 함수

Maxout 함수는 다음과 같다.

$f(x)=max({ w }_{ 1 }^{ T }x+{ b }_{ 1 },{ w }_{ 2 }^{ T }x+{ b }_{ 2 })$

이 함수는 ReLU가 가지는 모든 장점을 가졌으며, dying ReLU문제 또한 해결한다. 하지만 계산량이 복잡하다는 단점이 있다.

결론

위와 같이 여러 활성화 함수가 있는데, 어떤 함수를 사용해야 할지에 대한 결론은 다음고 같다.

우선 가장 많이 사용되는 함수는 ReLU이다. 간단하고 사용이 쉽기 때문에 우선적으로 ReLU를 사용한다.
ReLU를 사용한 이후 Leakly ReLU등 ReLU계열의 다른 함수도 사용 해본다.
sigmoid의 경우에는 사용하지 않도록 한다.
tanh의 경우도 큰 성능은 나오지 않는다.

참고

CNN을 활용한 주요 Model - (3) : Image Detection-2

2018-06-27T04:47:35+00:00

CNN을 활용한 주요 Model - (3) : Image Detection-2

Modern CNN
- LeNet
- AlexNet
- VGG Nets
- GoogLeNet
- ResNet
Image Detection
- RCNN
- Fast RCNN
- Faster RCNN
- SPP Net
- Yolo
- SDD
- Attention Net
Semantic Segmentation
- FCN
- DeepLab v1, v2
- U-Net
- ReSeg
Image Captioning

지난 포스트에 이어서 Image Detection에 사용된 Model들에 대해서 알아보도록 하겠다. 이번에 소개될 모델들은 지난 모델에 대해 좀 더 최신의 모델들로 성능 및 속도가 향상되었다는 것을 알 수 있다.

YOLO

딥러닝에서의 YOLO란 우리가 흔히 알고 있는 You Only Live Once의 약자가 아닌 You Only Look Once의 약자로 기존의 Object detection 알고리즘들의 속도가 real-time으로 사용하기에는 느리다는 문제점을 해결하기 위해 나온 알고리즘이다. YOLO의 가장 큰 특징은 이름에서 나오듯이 Image를 bounding box를 찾을때와 classification을 따로하는 것이 아니라 두가지를 한번에 한다는 것이다.

YOLO의 실행 과정에 대해 소개하면,

우선 Image를 S x S grid로 나눈다.
각각의 grid cell은 B개의 Bounding box에 대해 5개의 예측값을 갖는다. ($x,y$ : offset,$w,h$ : Bounding Box size, $conf$ : confidence score) confidence score은 bounding box가 해당 cell에 포함되지 않으면 0이 된다.
각각의 grid cell은 C개의 class에 대해 conditional class probability를 갖는다. (하나의 cell은 하나의 class에 대해 예측값 갖는다)

YOLO의 Architecture는 다음과 같다. Input size가 기존의 모델에 비해 448x448로 더욱 크다는 것을 알 수 있다. 그리고 중간의 Convolution layer들이 1x1, 3x3등 여러 size를 같이 사용하는 것이 Inception module과 비슷하다.

그러나 속도가 빠르고 backgorund에 대해 예측도 잘하는데도 불구하고 YOLO가 가지는 한계점은

각 cell은 2개의 bounding box와 하나의 class probability만을 예측한다. 따라서 작은 물체들에 대해서는 예측률이 낮다.
Loss fuction이 작은 bounding box와 큰 bounding box에 대해 error를 동일 하게 다루기 때문에, Scoring에 부적합 하다.
몇 단계를 거친 feature map에 대해서 예측하기 때문에, Localization이 부정확해 질 수 있다.

SSD

기존의 detection 모델들은 Bounding box를 만들고 각 box에 있는 feature를 extract한 후 classifier를 적용합니다. 하지만 이러한 과정은 real-time으로 적용하기에 느리고, 임베디드화 시키기에도 연산량이 너무 많다는 단점이 있다. 그에 반해 YOLO는 빠르다는 장점이 있지만 정확도가 떨어진다는 단점이 있다. SSD는 이러한 단점까지 보안한 Model이다. 각 모델들의 연산량과 정확도를 확인해보면,

Faster R-CNN : 7FPS, mAP 73.2% on VOC 2007
YOLO : 45FPS, mAP 63.4%
SSD : 59FPS, mAP 74.3% (FPS : Frame Per Second, mAP : mean AP)

SSD의 구조는 특별한 것이 아니라 기존의 Feed-Forward Convolutional Network에서 feature map까지를 하나로 보고 보조적 도구 몇 가지를 더하였다. 이 기본 구조는 VGG-16 network 에서 conv5_3까지를 잘라서 사용하였다.

SSD의 핵심은 다수의 conv feature map의 각 cell으로부터 category score와 box offset값을 예측하는 것이다.

Attention Net

Attention Net은 기존의 multiple detection이 아닌 single object에 대해 detection을 하는 model이다. 하나의 Object만 detect함에도 불구하고 이 모델이 의미있는 이유는 다음과 같다.

정확한 Bounding Box를 얻을 수 있다.
높은 성능
간단한 구조

기존의 모델에서 detection은 Object에 대해 알맞는 Bounding box를 찾는 문제 였지만, Attention Net에서는 Bounding box 크기를 조정하며 Object에 딱 맞는 Bounding box를 찾는 과정이라 할 수 있다.

Attention Net의 과정은 다음과 같다.

Input Image를 고정된 사이즈로 Reshape한다.
reshape된 image를 Convolution layer들을 통과시켜 크기 5의 2개의 벡터를 얻는다. 각각의 벡터는 Bounding box의 좌측 상단(TL), 좌측 하단(BR)에 대한 예측값이다.
이후 예측 값을 알맞게 예측됬는지를 확인하는 두개의 층을 통과시킨다. (예측이 제대로 되지 않았다면 다시 bounding box를 조정해 반복한다)

출처

CNN을 활용한 주요 Model - (2) : Image Detection

2018-06-27T04:47:35+00:00

CNN을 활용한 주요 Model - (2) : Image Detection

Modern CNN
- LeNet
- AlexNet
- VGG Nets
- GoogLeNet
- ResNet
Image Detection
- RCNN
- Fast RCNN
- Faster RCNN
- SPP Net
- Yolo
- SDD
- Attention Net
Semantic Segmentation
- FCN
- DeepLab v1, v2
- U-Net
- ReSeg
Image Captioning

Computer vision분야에는 다양한 문제들이 있다. 우선 Computer Vision의 Task들에 대해서 먼저 알아보자.

Classification이란, Object가 하나있는 image에 대해서 Object의 class를 분류하는 문제이다.
Classification과 Localization을 합친 문제는 Object의 class 분류와 object의 위치는 bounding box로 위치를 찾는 문제다.
Object Detection은 우선 Image에 있어 single object가 아닌 multiple object를 다루는 문제다. 각각의 Object에 대해 class를찾고 위치를 찾는 문제다.
Image Segmentation이란 Object Detection과 유사하지만, 다른점은 Object의 위치를 bounding box를 통해 나타내는것이 아닌 Object의 실제 edge를 찾아 정확한 형체까지 찾아 내는 문제이다.

이번 포스트에서는 Image Detection에서 사용된 CNN 모델들에 대해서 보도록한다.

RCNN, Fast RCNN, Faster RCNN

2013년의 RCNN의 등장이후 Fast RCNN, Faster RCNN 까지 RCNN모델들은 많은 사람들에게 영향을 주었으며, Computer Vision분야에서 가장 Impactful한 network라 할 수 있다.

RCNN

RCNN의 목적은 Object Detection 문제를 풀기 위함이다. 어떠한 이미지가 주어지면, 그 이미지에 있는 모든 Object들에 대해 Bounding box를 그리는 것이 최종 목적이다. 따라서 문제는 두가지 과정으로 나뉜다. 첫 번째, Resion Proposal과정과 Classification과정으로 나뉜다.

RCNN은 Selective Search를 사용한다. Selective Search란 Image에 대해서 2000개 정도의 각각 다른 region을 생성해낸 후 물체가 들어가 있을 확률이 가장 높은 것을 뽑는 과정이다. 이렇게 Region을 뽑아내는 Region proposal 과정을 거친 후 bounding된 Image들에 대해 AlexNet을 통과시켜 Feature extraction 과정을 거친다.(Image들은 AlexNet에 넣기 위해 227x227크기로 reshape한다) 이때 AlexNet을 통과시켜 나오는 최종 Output값을 뽑는 것이 아니라, 최종 출력층 이전 두 번째 FC Layer의 output 값인 4,096크기의 vector를 뽑는 것이다. 4,096크기의 vector에 대해 linear SVM(각 class들에 대해 사전 학습 된)을 통해 각 Region을 Scoring한다. 마지막으로 각 region들에 대해 Non-Maximum Suppression(NMS)를 사용해 bounding box를 구한다.

다시한번 과정을 정리하면

Selective Search Algorithms을 통해 2000개정도의 region을 생성한다.
각각의 region들을 228x228 크기로 Reshape한다.
reshape한 image들을 AlexNet을 통과시켜 마지막 output이전의 FC Layer의 output인 4,096크기의 vector를 뽑아낸다.
뽑아낸 vector를 SVM을 통해 classification을 한다.

RCNN의 Process를 보다보면 생각보다 복잡하며, 과도한 연산 및 손실되는 정보가 많은 것 같다는 생각이 든다. 실제로 2000개 정도의 region에 대해 연산을 실행하면서 연산량이 늘어나며 image를 reshape하며 손실되는 정보들 또한 많다는 단점이 있다.

Fast-RCNN

Fast-RCNN은 기존의 RCNN모델의 주요한 문제들을 해결하기 위해 나왔다.

RCNN은 학습을 위해 최소한 3가지 과정을 거쳐야한다.(CNN, SVM, region regression) 따라서 연산량이 매우 높아져서 속도가 매우느려 실제로 사용하기에 어렵다.

Fast RCNN의 과정을 설명하면

Image를 ConvNet을 통과시켜 ConvNet의 마지막 Feature map을 region proposal의 feature로 얻는다.
RoI Pooling layer를 통해 각각의 Bounding box에 대해 fixed-size의 feature vector를 얻는다.
마지막으로 feature vector에 대해 FC layer를 통해 class label과 bounding box location을 output으로 받는다.

여기서 처음에 통과시키는 ConvNet에서 Bounding box를 얻는 과정은 SPP Net의 방법과 유사하다. SPP Net에 대해서는 아래에서 보도록 하겠다.

Faster-RCNN

Faster RCNN은 RCNN과 Faster RCNN의 복잡한 학습과정 때문에 나오게 되었다. 여기서는 Region proposal network가 Convolution layer로 feature map을 뽑은 이후 나온다. Region Proposal Network외의 나머지 pipeline은 Fast-RCNN의 것과 똑같다.(ROI, FC, Classification, Regression)

SPP Net

SPP Net이란, Spatial Pyramid Pooling Network의 준말이다. SPPNet은 RCNN이 나온 후 등장한 Network이다. RCNN에서는 region을 여러개 뽑은 후 CNN에 넣게 되는데, CNN에 Input값으로 넣기 위해서는 fixed-size의 image가 되어야한다. 이 과정에서 많은 정보들이 손실되는 문제점이 발생한다. 따라서 region을 만든후 Convlution layer를 통과시키는 것이 아니라, 먼저 Convolution layer를 통과시킨다. 이때 각각의 filter들은 다양한 size의 feature map들을 만든다. 이렇게 만들어진 다양한 size의 map에 대해서 feature extraction을 수행한다.

그다음 SPP Net에서 사용한 중요한 구조는 이름에서도 알 수 있듯이 Spatial Pyramid Pooling Layer이다. 이전의 다양한 size에서 Extracted feature들을 SPP Layer를 통과시킨 후 FC-layer를 통해 최종 Output값을 얻는다.

가장 중요한 SPP Layer에 대해서 살펴보자. SPP Layer에서는 Conv Layer에서 나온 feature map들에 대해서 다양한 사이즈로 pooling을 진행한다.(1x1, 2x2, 3x3 등) 다양한 크기로 Pooling을 한 뒤 이 값들을 하나의 vector로 만들어준다.

이러한 과정을 통해 SPP Net은 RCNN에 비해 월등히 빠른 속도를 가지고 있다. 그럼에도 불구하고 학습이 어렵다는 단점과 여전히 Pipeline이 복잡하다는 단점이 존재한다.

YOLO

YOLO란 우리가 흔히 You Only Look Once의 약자로 기존의 Object detection 알고리즘들의 속도가 real-time으로 사용하기에는 느리다는 문제점을 해결하기 위해 나온 알고리즘이다. YOLO의 가장 큰 특징은 이름에서 나오듯이 Image를 bounding box를 찾을때와 classification을 따로하는 것이 아니라 두가지를 한번에 한다는 것이다.

YOLO의 실행 과정에 대해 소개하면,

우선 Image를 S x S grid로 나눈다.
각각의 grid cell은 B개의 Bounding box에 대해 5개의 예측값을 갖는다. ($x,y$ : offset,$w,h$ : Bounding Box size, $conf$ : confidence score) confidence score은 bounding box가 해당 cell에 포함되지 않으면 0이 된다.
각각의 grid cell은 C개의 class에 대해 conditional class probability를 갖는다. (하나의 cell은 하나의 class에 대해 예측값 갖는다)

그러나 속도가 빠르고 backgorund에 대해 예측도 잘하는데도 불구하고 YOLO가 가지는 한계점은

각 cell은 2개의 bounding box와 하나의 class probability만을 예측한다. 따라서 작은 물체들에 대해서는 예측률이 낮다.
Loss fuction이 작은 bounding box와 큰 bounding box에 대해 error를 동일 하게 다루기 때문에, Scoring에 부적합 하다.
몇 단계를 거친 feature map에 대해서 예측하기 때문에, Localization이 부정확해 질 수 있다.

출처

Bag of words meets bag of popcorn

2018-06-27T04:47:35+00:00

Bag of words meets bag of popcorn

Part 2 / Word Vector

word2vec 모델

논문

Efficient Estimation of Word Representations in Vector Space (2013, Mikolov)
- 초기버전
- CBOW ,Skip-gram
Distributed Representations of Words and Phrases and their Compositionality (2013,Mikolov)
- 튜닝기법이 추가

word2vec 관련 참고 자료

각 단어들을 원 핫인코딩 방식 혹은 Bag of words 방식으로 나타낼 경우 size가 매우 크고 벡터가 너무 sparse해서 neural net 성능이 잘 나오지 않는다.
단어 주변이 비슷하면 그 단어들은 의미가 유사하다는 아이디어
단어를 벡터로 바꿔주는 엠베딩(Embedding)과정
Word2Vec은 분산 된 텍스트 표현을 사용하여 개념 간 유사성을 본다. 예를 들어, 파리와 프랑스가 베를린과 독일이 (수도와 나라) 같은 방식으로 관련되어 있음을 이해한다.

5 CBOW와 Skip-gram 기법 사용

CBOW
- CBOW(continuous bag-of-words)
- 전체 텍스트로 하나의 단어를 예측한다.
- 작은 데이터셋일수록 유리
Skip-Gram
- 타겟 단어들로 부터 원본 단어들을 역으로 유추하는 과정
- 큰 규모의 데이터셋일수록 유리

# 참고 : https://gist.github.com/yong27/7869662
# http://www.racketracer.com/2016/07/06/pandas-in-parallel/
from multiprocessing import Pool
import numpy as np

def _apply_df(args):
    df, func, kwargs = args
    return df.apply(func, **kwargs)

def apply_by_multiprocessing(df, func, **kwargs):
    # 키워드 항목 중 workers 파라메터를 꺼냄
    workers = kwargs.pop('workers')
    # 위에서 가져온 workers 수로 프로세스 풀을 정의
    pool = Pool(processes=workers)
    # 실행할 함수와 데이터프레임을 워커의 수 만큼 나눠 작업
    result = pool.map(_apply_df, [(d, func, kwargs)
            for d in np.array_split(df, workers)])
    pool.close()
    # 작업 결과를 합쳐서 반환
    return pd.concat(list(result))

from kaggleBagofWord import kaggleBagofWord
##전처리과정에 사용하는 것들을 class화~

import pandas as pd

train = pd.read_csv('data/labeledTrainData.tsv',
                    header=0, delimiter='\t', quoting=3)
test = pd.read_csv('data/testData.tsv',
                   header=0, delimiter='\t', quoting=3)
unlabeled_train = pd.read_csv('data/unlabeledTrainData.tsv',
                              header=0, delimiter='\t', quoting=3)

print(train.shape)
print(test.shape)
print(unlabeled_train.shape)

print(train['review'].size)
print(test['review'].size)
print(unlabeled_train['review'].size)

kaggleBagofWord.review_to_wordlist(train['review'][0])[:10]

['with', 'all', 'this', 'stuff', 'go', 'down', 'at', 'the', 'moment', 'with']

sentences = []
for review in train["review"]:
    sentences += kaggleBagofWord.review_to_sentences(
        review, remove_stopwords=False)

C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'.'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'...'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://www.happierabroad.com"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'12.'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'music.'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)

for review in unlabeled_train["review"]:
    sentences += kaggleBagofWord.review_to_sentences(
        review, remove_stopwords=False)

C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'.'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://www.archive.org/details/LovefromaStranger"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://www.loosechangeguide.com/LooseChangeGuide.html"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'... ...'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'...'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'....'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://www.msnbc.msn.com/id/4972055/site/newsweek/"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'12.'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'..'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://www.youtube.com/watch?v=a0KSqelmgN8"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:219: UserWarning: "b'.. .'" looks like a filename, not markup. You should probably open this file and pass the filehandle into Beautiful Soup.
  ' Beautiful Soup.' % markup)
C:\ProgramData\Anaconda3\lib\site-packages\bs4\__init__.py:282: UserWarning: "http://jake-weird.blogspot.com/2007/08/beneath.html"" looks like a URL. Beautiful Soup is not an HTTP client. You should probably use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.
  ' that document to Beautiful Soup.' % decoded_markup

len(sentences)

sentences[0][:10]

['with', 'all', 'this', 'stuff', 'go', 'down', 'at', 'the', 'moment', 'with']

sentences[1][:10]

['mayb', 'i', 'just', 'want', 'to', 'get', 'a', 'certain', 'insight', 'into']

Word2Vec 모델의 파라메터

아키텍처 : 아키텍처 옵션은 skip-gram (default) 또는 CBOW 모델이다. skip-gram (default)은 느리지 만 더 나은 결과를 낸다.
학습 알고리즘 : Hierarchical softmax (default) 또는 negative 샘플링. 여기에서는 기본값이 잘 동작한다.
빈번하게 등장하는 단어에 대한 다운 샘플링 : Google 문서는 .00001에서 .001 사이의 값을 권장한다. 여기에서는 0.001에 가까운 값이 최종 모델의 정확도를 높이는 것으로 보여진다.
단어 벡터 차원 : 많은 feature를 사용한다고 항상 좋은 것은 아니지만 대체적으로 좀 더 나은 모델이 된다. 합리적인 값은 수십에서 수백 개가 될 수 있고 여기에서는 300으로 지정했다.
컨텍스트 / 창 크기 : 학습 알고리즘이 고려해야하는 컨텍스트의 단어 수는 얼마나 될까? hierarchical softmax 를 위해 좀 더 큰 수가 좋지만 10 정도가 적당하다.
Worker threads : 실행할 병렬 프로세스의 수로 컴퓨터마다 다르지만 대부분의 시스템에서 4에서 6 사이의 값을 사용하다.
최소 단어 수 : 어휘의 크기를 의미있는 단어로 제한하는 데 도움이 된다. 모든 문서에서이 여러 번 발생하지 않는 단어는 무시된다. 10에서 100 사이가 적당하며, 이 경진대회의 데이터는 각 영화가 30개씩의 리뷰가 있기 때문에 개별 영화 제목에 너무 많은 중요성이 붙는 것을 피하기 위해 최소 단어 수를 40으로 설정한다. 그 결과 전체 어휘 크기는 약 15,000 단어가 된다. 높은 값은 제한 된 실행시간에 도움이 된다.

import logging
logging.basicConfig(
    format='%(asctime)s : %(levelname)s : %(message)s',
    level=logging.INFO)

# 파라메터값 지정
num_features = 300 # 문자 벡터 차원 수
min_word_count = 40 # 최소 단어 수
num_workers = 4 # 병렬 처리 스레드 수
context = 10 # 문자열 창 크기
downsampling = 1e-3 # 문자 빈도 수 Downsample

# 초기화 및 모델 학습
from gensim.models import word2vec

# 모델 학습
model = word2vec.Word2Vec(sentences,
                          workers=num_workers,
                          size=num_features,
                          min_count=min_word_count,
                          window=context,
                          sample=downsampling)
model

C:\ProgramData\Anaconda3\lib\site-packages\gensim-3.4.0-py3.6-win-amd64.egg\gensim\utils.py:1197: UserWarning: detected Windows; aliasing chunkize to chunkize_serial
  warnings.warn("detected Windows; aliasing chunkize to chunkize_serial")
2018-04-30 12:06:49,740 : INFO : 'pattern' package not found; tag filters are not available for English
2018-04-30 12:06:49,755 : INFO : collecting all words and their counts
2018-04-30 12:06:49,756 : INFO : PROGRESS: at sentence #0, processed 0 words, keeping 0 word types
2018-04-30 12:06:49,831 : INFO : PROGRESS: at sentence #10000, processed 225803 words, keeping 12465 word types
2018-04-30 12:06:49,912 : INFO : PROGRESS: at sentence #20000, processed 451892 words, keeping 17070 word types
2018-04-30 12:06:49,990 : INFO : PROGRESS: at sentence #30000, processed 671315 words, keeping 20370 word types
2018-04-30 12:06:50,077 : INFO : PROGRESS: at sentence #40000, processed 897815 words, keeping 23125 word types
2018-04-30 12:06:50,154 : INFO : PROGRESS: at sentence #50000, processed 1116963 words, keeping 25365 word types
2018-04-30 12:06:50,253 : INFO : PROGRESS: at sentence #60000, processed 1338404 words, keeping 27283 word types
2018-04-30 12:06:50,342 : INFO : PROGRESS: at sentence #70000, processed 1561580 words, keeping 29024 word types
2018-04-30 12:06:50,435 : INFO : PROGRESS: at sentence #80000, processed 1780887 words, keeping 30603 word types
2018-04-30 12:06:50,537 : INFO : PROGRESS: at sentence #90000, processed 2004996 words, keeping 32223 word types
2018-04-30 12:06:50,628 : INFO : PROGRESS: at sentence #100000, processed 2226967 words, keeping 33579 word types
2018-04-30 12:06:50,717 : INFO : PROGRESS: at sentence #110000, processed 2446581 words, keeping 34827 word types
2018-04-30 12:06:50,790 : INFO : PROGRESS: at sentence #120000, processed 2668776 words, keeping 36183 word types
2018-04-30 12:06:50,886 : INFO : PROGRESS: at sentence #130000, processed 2894304 words, keeping 37353 word types
2018-04-30 12:06:50,999 : INFO : PROGRESS: at sentence #140000, processed 3107006 words, keeping 38376 word types
2018-04-30 12:06:51,128 : INFO : PROGRESS: at sentence #150000, processed 3332628 words, keeping 39556 word types
2018-04-30 12:06:51,248 : INFO : PROGRESS: at sentence #160000, processed 3555316 words, keeping 40629 word types
2018-04-30 12:06:51,364 : INFO : PROGRESS: at sentence #170000, processed 3778656 words, keeping 41628 word types
2018-04-30 12:06:51,477 : INFO : PROGRESS: at sentence #180000, processed 3999237 words, keeping 42599 word types
2018-04-30 12:06:51,589 : INFO : PROGRESS: at sentence #190000, processed 4224450 words, keeping 43461 word types
2018-04-30 12:06:51,685 : INFO : PROGRESS: at sentence #200000, processed 4448604 words, keeping 44301 word types
2018-04-30 12:06:51,771 : INFO : PROGRESS: at sentence #210000, processed 4669968 words, keeping 45212 word types
2018-04-30 12:06:51,863 : INFO : PROGRESS: at sentence #220000, processed 4894969 words, keeping 46134 word types
2018-04-30 12:06:52,013 : INFO : PROGRESS: at sentence #230000, processed 5117546 words, keeping 46986 word types
2018-04-30 12:06:52,126 : INFO : PROGRESS: at sentence #240000, processed 5345051 words, keeping 47854 word types
2018-04-30 12:06:52,229 : INFO : PROGRESS: at sentence #250000, processed 5559166 words, keeping 48699 word types
2018-04-30 12:06:52,345 : INFO : PROGRESS: at sentence #260000, processed 5779147 words, keeping 49469 word types
2018-04-30 12:06:52,438 : INFO : PROGRESS: at sentence #270000, processed 6000436 words, keeping 50416 word types
2018-04-30 12:06:52,525 : INFO : PROGRESS: at sentence #280000, processed 6226315 words, keeping 51640 word types
2018-04-30 12:06:52,612 : INFO : PROGRESS: at sentence #290000, processed 6449475 words, keeping 52754 word types
2018-04-30 12:06:52,694 : INFO : PROGRESS: at sentence #300000, processed 6674078 words, keeping 53755 word types
2018-04-30 12:06:52,782 : INFO : PROGRESS: at sentence #310000, processed 6899392 words, keeping 54734 word types
2018-04-30 12:06:52,871 : INFO : PROGRESS: at sentence #320000, processed 7124279 words, keeping 55770 word types
2018-04-30 12:06:52,953 : INFO : PROGRESS: at sentence #330000, processed 7346022 words, keeping 56687 word types
2018-04-30 12:06:53,036 : INFO : PROGRESS: at sentence #340000, processed 7575534 words, keeping 57629 word types
2018-04-30 12:06:53,133 : INFO : PROGRESS: at sentence #350000, processed 7798804 words, keeping 58485 word types
2018-04-30 12:06:53,208 : INFO : PROGRESS: at sentence #360000, processed 8019467 words, keeping 59345 word types
2018-04-30 12:06:53,296 : INFO : PROGRESS: at sentence #370000, processed 8246659 words, keeping 60161 word types
2018-04-30 12:06:53,379 : INFO : PROGRESS: at sentence #380000, processed 8471806 words, keeping 61069 word types
2018-04-30 12:06:53,467 : INFO : PROGRESS: at sentence #390000, processed 8701556 words, keeping 61810 word types
2018-04-30 12:06:53,546 : INFO : PROGRESS: at sentence #400000, processed 8924505 words, keeping 62546 word types
2018-04-30 12:06:53,634 : INFO : PROGRESS: at sentence #410000, processed 9145855 words, keeping 63263 word types
2018-04-30 12:06:53,716 : INFO : PROGRESS: at sentence #420000, processed 9366935 words, keeping 64024 word types
2018-04-30 12:06:53,797 : INFO : PROGRESS: at sentence #430000, processed 9594472 words, keeping 64795 word types
2018-04-30 12:06:53,882 : INFO : PROGRESS: at sentence #440000, processed 9821225 words, keeping 65539 word types
2018-04-30 12:06:53,966 : INFO : PROGRESS: at sentence #450000, processed 10044987 words, keeping 66378 word types
2018-04-30 12:06:54,047 : INFO : PROGRESS: at sentence #460000, processed 10277747 words, keeping 67158 word types
2018-04-30 12:06:54,141 : INFO : PROGRESS: at sentence #470000, processed 10505672 words, keeping 67775 word types
2018-04-30 12:06:54,220 : INFO : PROGRESS: at sentence #480000, processed 10726056 words, keeping 68500 word types
2018-04-30 12:06:54,308 : INFO : PROGRESS: at sentence #490000, processed 10952800 words, keeping 69256 word types
2018-04-30 12:06:54,409 : INFO : PROGRESS: at sentence #500000, processed 11174456 words, keeping 69892 word types
2018-04-30 12:06:54,485 : INFO : PROGRESS: at sentence #510000, processed 11399731 words, keeping 70593 word types
2018-04-30 12:06:54,554 : INFO : PROGRESS: at sentence #520000, processed 11623082 words, keeping 71267 word types
2018-04-30 12:06:54,630 : INFO : PROGRESS: at sentence #530000, processed 11847480 words, keeping 71877 word types
2018-04-30 12:06:54,703 : INFO : PROGRESS: at sentence #540000, processed 12072095 words, keeping 72537 word types
2018-04-30 12:06:54,789 : INFO : PROGRESS: at sentence #550000, processed 12297646 words, keeping 73212 word types
2018-04-30 12:06:54,873 : INFO : PROGRESS: at sentence #560000, processed 12518936 words, keeping 73861 word types
2018-04-30 12:06:54,961 : INFO : PROGRESS: at sentence #570000, processed 12748083 words, keeping 74431 word types
2018-04-30 12:06:55,074 : INFO : PROGRESS: at sentence #580000, processed 12969579 words, keeping 75087 word types
2018-04-30 12:06:55,232 : INFO : PROGRESS: at sentence #590000, processed 13195104 words, keeping 75733 word types
2018-04-30 12:06:55,349 : INFO : PROGRESS: at sentence #600000, processed 13417302 words, keeping 76294 word types
2018-04-30 12:06:55,458 : INFO : PROGRESS: at sentence #610000, processed 13638325 words, keeping 76952 word types
2018-04-30 12:06:55,556 : INFO : PROGRESS: at sentence #620000, processed 13864650 words, keeping 77503 word types
2018-04-30 12:06:55,644 : INFO : PROGRESS: at sentence #630000, processed 14088936 words, keeping 78066 word types
2018-04-30 12:06:55,726 : INFO : PROGRESS: at sentence #640000, processed 14309719 words, keeping 78692 word types
2018-04-30 12:06:55,805 : INFO : PROGRESS: at sentence #650000, processed 14535475 words, keeping 79295 word types
2018-04-30 12:06:55,888 : INFO : PROGRESS: at sentence #660000, processed 14758265 words, keeping 79864 word types
2018-04-30 12:06:55,973 : INFO : PROGRESS: at sentence #670000, processed 14981658 words, keeping 80381 word types
2018-04-30 12:06:56,060 : INFO : PROGRESS: at sentence #680000, processed 15206490 words, keeping 80912 word types
2018-04-30 12:06:56,141 : INFO : PROGRESS: at sentence #690000, processed 15428683 words, keeping 81482 word types
2018-04-30 12:06:56,227 : INFO : PROGRESS: at sentence #700000, processed 15657389 words, keeping 82074 word types
2018-04-30 12:06:56,316 : INFO : PROGRESS: at sentence #710000, processed 15880378 words, keeping 82560 word types
2018-04-30 12:06:56,411 : INFO : PROGRESS: at sentence #720000, processed 16105665 words, keeping 83036 word types
2018-04-30 12:06:56,492 : INFO : PROGRESS: at sentence #730000, processed 16332046 words, keeping 83571 word types
2018-04-30 12:06:56,578 : INFO : PROGRESS: at sentence #740000, processed 16553079 words, keeping 84127 word types
2018-04-30 12:06:56,657 : INFO : PROGRESS: at sentence #750000, processed 16771406 words, keeping 84599 word types
2018-04-30 12:06:56,735 : INFO : PROGRESS: at sentence #760000, processed 16990810 words, keeping 85068 word types
2018-04-30 12:06:56,818 : INFO : PROGRESS: at sentence #770000, processed 17217947 words, keeping 85644 word types
2018-04-30 12:06:56,906 : INFO : PROGRESS: at sentence #780000, processed 17448093 words, keeping 86160 word types
2018-04-30 12:06:56,996 : INFO : PROGRESS: at sentence #790000, processed 17675169 words, keeping 86665 word types
2018-04-30 12:06:57,045 : INFO : collected 86996 word types from a corpus of 17798270 raw words and 795538 sentences
2018-04-30 12:06:57,045 : INFO : Loading a fresh vocabulary
2018-04-30 12:06:57,131 : INFO : min_count=40 retains 11986 unique words (13% of original 86996, drops 75010)
2018-04-30 12:06:57,133 : INFO : min_count=40 leaves 17434033 word corpus (97% of original 17798270, drops 364237)
2018-04-30 12:06:57,209 : INFO : deleting the raw counts dictionary of 86996 items
2018-04-30 12:06:57,216 : INFO : sample=0.001 downsamples 50 most-common words
2018-04-30 12:06:57,217 : INFO : downsampling leaves estimated 12872363 word corpus (73.8% of prior 17434033)
2018-04-30 12:06:57,281 : INFO : estimated required memory for 11986 words and 300 dimensions: 34759400 bytes
2018-04-30 12:06:57,282 : INFO : resetting layer weights
2018-04-30 12:06:57,559 : INFO : training model with 4 workers on 11986 vocabulary and 300 features, using sg=0 hs=0 sample=0.001 negative=5 window=10
2018-04-30 12:06:58,622 : INFO : EPOCH 1 - PROGRESS: at 3.42% examples, 427165 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:06:59,625 : INFO : EPOCH 1 - PROGRESS: at 6.68% examples, 422080 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:00,629 : INFO : EPOCH 1 - PROGRESS: at 9.81% examples, 413311 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:01,661 : INFO : EPOCH 1 - PROGRESS: at 13.08% examples, 411567 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:02,692 : INFO : EPOCH 1 - PROGRESS: at 16.72% examples, 418921 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:03,708 : INFO : EPOCH 1 - PROGRESS: at 19.38% examples, 404802 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:04,719 : INFO : EPOCH 1 - PROGRESS: at 21.80% examples, 391006 words/s, in_qsize 8, out_qsize 1
2018-04-30 12:07:05,725 : INFO : EPOCH 1 - PROGRESS: at 24.56% examples, 386193 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:06,724 : INFO : EPOCH 1 - PROGRESS: at 26.97% examples, 377823 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:07,738 : INFO : EPOCH 1 - PROGRESS: at 29.47% examples, 372069 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:07:08,756 : INFO : EPOCH 1 - PROGRESS: at 32.18% examples, 368533 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:09,779 : INFO : EPOCH 1 - PROGRESS: at 34.27% examples, 359451 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:10,806 : INFO : EPOCH 1 - PROGRESS: at 36.11% examples, 349544 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:11,835 : INFO : EPOCH 1 - PROGRESS: at 37.73% examples, 339030 words/s, in_qsize 8, out_qsize 2
2018-04-30 12:07:12,914 : INFO : EPOCH 1 - PROGRESS: at 40.80% examples, 341046 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:13,915 : INFO : EPOCH 1 - PROGRESS: at 42.41% examples, 332956 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:14,935 : INFO : EPOCH 1 - PROGRESS: at 44.89% examples, 331693 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:15,974 : INFO : EPOCH 1 - PROGRESS: at 47.28% examples, 329834 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:16,983 : INFO : EPOCH 1 - PROGRESS: at 49.65% examples, 328681 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:17,999 : INFO : EPOCH 1 - PROGRESS: at 52.43% examples, 329647 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:19,009 : INFO : EPOCH 1 - PROGRESS: at 54.99% examples, 329598 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:20,031 : INFO : EPOCH 1 - PROGRESS: at 57.42% examples, 328726 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:21,038 : INFO : EPOCH 1 - PROGRESS: at 59.85% examples, 328154 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:22,049 : INFO : EPOCH 1 - PROGRESS: at 62.82% examples, 330233 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:23,065 : INFO : EPOCH 1 - PROGRESS: at 65.18% examples, 328977 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:24,103 : INFO : EPOCH 1 - PROGRESS: at 67.12% examples, 325612 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:25,119 : INFO : EPOCH 1 - PROGRESS: at 68.38% examples, 319379 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:26,120 : INFO : EPOCH 1 - PROGRESS: at 70.39% examples, 317302 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:27,124 : INFO : EPOCH 1 - PROGRESS: at 72.49% examples, 315815 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:28,130 : INFO : EPOCH 1 - PROGRESS: at 75.48% examples, 317963 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:29,141 : INFO : EPOCH 1 - PROGRESS: at 77.66% examples, 316696 words/s, in_qsize 7, out_qsize 1
2018-04-30 12:07:30,164 : INFO : EPOCH 1 - PROGRESS: at 79.92% examples, 315602 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:31,172 : INFO : EPOCH 1 - PROGRESS: at 81.98% examples, 314064 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:32,200 : INFO : EPOCH 1 - PROGRESS: at 83.84% examples, 311640 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:33,222 : INFO : EPOCH 1 - PROGRESS: at 85.63% examples, 309199 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:07:34,268 : INFO : EPOCH 1 - PROGRESS: at 87.69% examples, 307650 words/s, in_qsize 7, out_qsize 1
2018-04-30 12:07:35,278 : INFO : EPOCH 1 - PROGRESS: at 90.07% examples, 307646 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:36,278 : INFO : EPOCH 1 - PROGRESS: at 91.92% examples, 305841 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:37,297 : INFO : EPOCH 1 - PROGRESS: at 94.15% examples, 305076 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:38,300 : INFO : EPOCH 1 - PROGRESS: at 96.53% examples, 305000 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:39,314 : INFO : EPOCH 1 - PROGRESS: at 98.72% examples, 304525 words/s, in_qsize 7, out_qsize 1
2018-04-30 12:07:39,910 : INFO : worker thread finished; awaiting finish of 3 more threads
2018-04-30 12:07:39,949 : INFO : worker thread finished; awaiting finish of 2 more threads
2018-04-30 12:07:39,970 : INFO : worker thread finished; awaiting finish of 1 more threads
2018-04-30 12:07:39,998 : INFO : worker thread finished; awaiting finish of 0 more threads
2018-04-30 12:07:40,000 : INFO : EPOCH - 1 : training on 17798270 raw words (12871193 effective words) took 42.4s, 303498 effective words/s
2018-04-30 12:07:41,052 : INFO : EPOCH 2 - PROGRESS: at 2.45% examples, 308316 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:42,073 : INFO : EPOCH 2 - PROGRESS: at 4.59% examples, 288681 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:43,118 : INFO : EPOCH 2 - PROGRESS: at 7.30% examples, 303057 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:44,125 : INFO : EPOCH 2 - PROGRESS: at 9.29% examples, 290343 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:45,150 : INFO : EPOCH 2 - PROGRESS: at 11.20% examples, 280107 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:46,152 : INFO : EPOCH 2 - PROGRESS: at 13.03% examples, 272151 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:47,162 : INFO : EPOCH 2 - PROGRESS: at 14.72% examples, 264022 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:48,234 : INFO : EPOCH 2 - PROGRESS: at 16.29% examples, 254190 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:49,266 : INFO : EPOCH 2 - PROGRESS: at 18.42% examples, 254662 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:50,266 : INFO : EPOCH 2 - PROGRESS: at 20.73% examples, 258713 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:51,269 : INFO : EPOCH 2 - PROGRESS: at 23.04% examples, 261984 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:52,282 : INFO : EPOCH 2 - PROGRESS: at 25.22% examples, 263287 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:53,303 : INFO : EPOCH 2 - PROGRESS: at 26.91% examples, 259337 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:54,304 : INFO : EPOCH 2 - PROGRESS: at 29.98% examples, 268955 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:55,304 : INFO : EPOCH 2 - PROGRESS: at 33.03% examples, 276327 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:56,321 : INFO : EPOCH 2 - PROGRESS: at 35.33% examples, 277230 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:57,359 : INFO : EPOCH 2 - PROGRESS: at 38.01% examples, 280612 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:07:58,371 : INFO : EPOCH 2 - PROGRESS: at 40.46% examples, 282449 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:07:59,381 : INFO : EPOCH 2 - PROGRESS: at 43.36% examples, 287092 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:00,390 : INFO : EPOCH 2 - PROGRESS: at 45.89% examples, 288824 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:01,406 : INFO : EPOCH 2 - PROGRESS: at 48.16% examples, 288917 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:02,451 : INFO : EPOCH 2 - PROGRESS: at 50.68% examples, 289948 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:03,521 : INFO : EPOCH 2 - PROGRESS: at 53.10% examples, 289944 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:04,538 : INFO : EPOCH 2 - PROGRESS: at 54.81% examples, 287055 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:05,539 : INFO : EPOCH 2 - PROGRESS: at 56.72% examples, 285394 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:06,541 : INFO : EPOCH 2 - PROGRESS: at 58.63% examples, 284133 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:07,542 : INFO : EPOCH 2 - PROGRESS: at 60.64% examples, 283253 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:08,562 : INFO : EPOCH 2 - PROGRESS: at 63.10% examples, 284282 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:09,583 : INFO : EPOCH 2 - PROGRESS: at 65.57% examples, 285213 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:10,602 : INFO : EPOCH 2 - PROGRESS: at 67.97% examples, 285854 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:11,661 : INFO : EPOCH 2 - PROGRESS: at 70.60% examples, 287023 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:12,662 : INFO : EPOCH 2 - PROGRESS: at 72.72% examples, 286639 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:13,682 : INFO : EPOCH 2 - PROGRESS: at 74.80% examples, 285883 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:14,713 : INFO : EPOCH 2 - PROGRESS: at 77.10% examples, 285918 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:15,742 : INFO : EPOCH 2 - PROGRESS: at 79.57% examples, 286573 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:16,743 : INFO : EPOCH 2 - PROGRESS: at 82.09% examples, 287607 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:17,759 : INFO : EPOCH 2 - PROGRESS: at 84.67% examples, 288667 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:18,763 : INFO : EPOCH 2 - PROGRESS: at 87.64% examples, 291075 words/s, in_qsize 7, out_qsize 1
2018-04-30 12:08:19,765 : INFO : EPOCH 2 - PROGRESS: at 90.31% examples, 292449 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:20,779 : INFO : EPOCH 2 - PROGRESS: at 93.80% examples, 296159 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:21,802 : INFO : EPOCH 2 - PROGRESS: at 97.35% examples, 299801 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:22,540 : INFO : worker thread finished; awaiting finish of 3 more threads
2018-04-30 12:08:22,558 : INFO : worker thread finished; awaiting finish of 2 more threads
2018-04-30 12:08:22,574 : INFO : worker thread finished; awaiting finish of 1 more threads
2018-04-30 12:08:22,578 : INFO : worker thread finished; awaiting finish of 0 more threads
2018-04-30 12:08:22,579 : INFO : EPOCH - 2 : training on 17798270 raw words (12872113 effective words) took 42.6s, 302461 effective words/s
2018-04-30 12:08:23,608 : INFO : EPOCH 3 - PROGRESS: at 3.36% examples, 426875 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:24,615 : INFO : EPOCH 3 - PROGRESS: at 6.90% examples, 438685 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:25,630 : INFO : EPOCH 3 - PROGRESS: at 10.37% examples, 437207 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:26,642 : INFO : EPOCH 3 - PROGRESS: at 13.43% examples, 424408 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:27,645 : INFO : EPOCH 3 - PROGRESS: at 16.50% examples, 417336 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:28,659 : INFO : EPOCH 3 - PROGRESS: at 19.94% examples, 420156 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:29,661 : INFO : EPOCH 3 - PROGRESS: at 23.38% examples, 422990 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:30,667 : INFO : EPOCH 3 - PROGRESS: at 26.18% examples, 414959 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:31,669 : INFO : EPOCH 3 - PROGRESS: at 28.99% examples, 408924 words/s, in_qsize 8, out_qsize 1
2018-04-30 12:08:32,673 : INFO : EPOCH 3 - PROGRESS: at 31.67% examples, 401902 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:33,696 : INFO : EPOCH 3 - PROGRESS: at 34.76% examples, 400514 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:34,707 : INFO : EPOCH 3 - PROGRESS: at 37.62% examples, 397562 words/s, in_qsize 8, out_qsize 1
2018-04-30 12:08:35,734 : INFO : EPOCH 3 - PROGRESS: at 40.80% examples, 397784 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:36,737 : INFO : EPOCH 3 - PROGRESS: at 43.69% examples, 396176 words/s, in_qsize 8, out_qsize 1
2018-04-30 12:08:37,745 : INFO : EPOCH 3 - PROGRESS: at 46.72% examples, 395548 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:38,764 : INFO : EPOCH 3 - PROGRESS: at 49.94% examples, 396492 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:39,810 : INFO : EPOCH 3 - PROGRESS: at 53.10% examples, 395892 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:40,816 : INFO : EPOCH 3 - PROGRESS: at 56.49% examples, 398171 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:41,831 : INFO : EPOCH 3 - PROGRESS: at 59.84% examples, 400068 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:42,834 : INFO : EPOCH 3 - PROGRESS: at 62.99% examples, 400243 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:43,846 : INFO : EPOCH 3 - PROGRESS: at 66.28% examples, 401222 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:44,884 : INFO : EPOCH 3 - PROGRESS: at 68.72% examples, 396460 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:45,894 : INFO : EPOCH 3 - PROGRESS: at 70.27% examples, 387967 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:46,898 : INFO : EPOCH 3 - PROGRESS: at 72.72% examples, 385020 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:47,916 : INFO : EPOCH 3 - PROGRESS: at 75.82% examples, 385212 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:48,924 : INFO : EPOCH 3 - PROGRESS: at 79.06% examples, 386378 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:49,946 : INFO : EPOCH 3 - PROGRESS: at 82.09% examples, 386199 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:50,950 : INFO : EPOCH 3 - PROGRESS: at 84.17% examples, 381952 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:51,969 : INFO : EPOCH 3 - PROGRESS: at 86.53% examples, 379028 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:52,997 : INFO : EPOCH 3 - PROGRESS: at 88.81% examples, 375949 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:08:54,001 : INFO : EPOCH 3 - PROGRESS: at 90.82% examples, 372184 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:55,048 : INFO : EPOCH 3 - PROGRESS: at 93.01% examples, 368873 words/s, in_qsize 8, out_qsize 1
2018-04-30 12:08:56,057 : INFO : EPOCH 3 - PROGRESS: at 95.59% examples, 367458 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:57,073 : INFO : EPOCH 3 - PROGRESS: at 98.11% examples, 366274 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:08:57,760 : INFO : worker thread finished; awaiting finish of 3 more threads
2018-04-30 12:08:57,811 : INFO : worker thread finished; awaiting finish of 2 more threads
2018-04-30 12:08:57,816 : INFO : worker thread finished; awaiting finish of 1 more threads
2018-04-30 12:08:57,822 : INFO : worker thread finished; awaiting finish of 0 more threads
2018-04-30 12:08:57,825 : INFO : EPOCH - 3 : training on 17798270 raw words (12874360 effective words) took 35.2s, 365412 effective words/s
2018-04-30 12:08:58,843 : INFO : EPOCH 4 - PROGRESS: at 2.29% examples, 294724 words/s, in_qsize 7, out_qsize 1
2018-04-30 12:08:59,845 : INFO : EPOCH 4 - PROGRESS: at 5.03% examples, 323737 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:00,850 : INFO : EPOCH 4 - PROGRESS: at 7.54% examples, 321039 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:01,855 : INFO : EPOCH 4 - PROGRESS: at 9.00% examples, 287446 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:09:02,921 : INFO : EPOCH 4 - PROGRESS: at 10.76% examples, 271258 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:03,924 : INFO : EPOCH 4 - PROGRESS: at 12.68% examples, 266864 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:04,931 : INFO : EPOCH 4 - PROGRESS: at 14.45% examples, 260620 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:05,954 : INFO : EPOCH 4 - PROGRESS: at 15.95% examples, 251781 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:06,980 : INFO : EPOCH 4 - PROGRESS: at 17.52% examples, 244878 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:07,999 : INFO : EPOCH 4 - PROGRESS: at 19.21% examples, 241613 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:09,020 : INFO : EPOCH 4 - PROGRESS: at 21.24% examples, 242812 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:10,037 : INFO : EPOCH 4 - PROGRESS: at 22.98% examples, 240963 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:11,067 : INFO : EPOCH 4 - PROGRESS: at 25.00% examples, 241868 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:12,066 : INFO : EPOCH 4 - PROGRESS: at 26.91% examples, 242089 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:09:13,144 : INFO : EPOCH 4 - PROGRESS: at 29.04% examples, 242988 words/s, in_qsize 8, out_qsize 2
2018-04-30 12:09:14,288 : INFO : EPOCH 4 - PROGRESS: at 31.20% examples, 242746 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:15,319 : INFO : EPOCH 4 - PROGRESS: at 32.97% examples, 241197 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:16,359 : INFO : EPOCH 4 - PROGRESS: at 34.65% examples, 239327 words/s, in_qsize 6, out_qsize 0
2018-04-30 12:09:17,377 : INFO : EPOCH 4 - PROGRESS: at 36.34% examples, 237946 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:18,407 : INFO : EPOCH 4 - PROGRESS: at 38.40% examples, 239011 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:19,442 : INFO : EPOCH 4 - PROGRESS: at 40.13% examples, 237942 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:20,494 : INFO : EPOCH 4 - PROGRESS: at 42.14% examples, 238351 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:21,521 : INFO : EPOCH 4 - PROGRESS: at 43.92% examples, 237784 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:22,538 : INFO : EPOCH 4 - PROGRESS: at 45.71% examples, 237327 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:23,553 : INFO : EPOCH 4 - PROGRESS: at 47.62% examples, 237505 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:24,612 : INFO : EPOCH 4 - PROGRESS: at 49.66% examples, 238085 words/s, in_qsize 6, out_qsize 2
2018-04-30 12:09:25,636 : INFO : EPOCH 4 - PROGRESS: at 51.31% examples, 236856 words/s, in_qsize 8, out_qsize 2
2018-04-30 12:09:26,653 : INFO : EPOCH 4 - PROGRESS: at 53.43% examples, 238013 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:27,726 : INFO : EPOCH 4 - PROGRESS: at 54.81% examples, 235514 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:28,731 : INFO : EPOCH 4 - PROGRESS: at 55.94% examples, 232529 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:29,882 : INFO : EPOCH 4 - PROGRESS: at 57.73% examples, 231598 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:09:30,929 : INFO : EPOCH 4 - PROGRESS: at 59.39% examples, 230825 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:31,968 : INFO : EPOCH 4 - PROGRESS: at 61.02% examples, 229926 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:32,976 : INFO : EPOCH 4 - PROGRESS: at 63.16% examples, 231149 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:33,992 : INFO : EPOCH 4 - PROGRESS: at 64.73% examples, 230245 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:35,003 : INFO : EPOCH 4 - PROGRESS: at 67.29% examples, 232907 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:36,040 : INFO : EPOCH 4 - PROGRESS: at 69.03% examples, 232444 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:37,047 : INFO : EPOCH 4 - PROGRESS: at 71.54% examples, 234763 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:09:38,075 : INFO : EPOCH 4 - PROGRESS: at 74.12% examples, 237022 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:39,090 : INFO : EPOCH 4 - PROGRESS: at 77.21% examples, 240818 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:40,091 : INFO : EPOCH 4 - PROGRESS: at 79.34% examples, 241612 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:41,121 : INFO : EPOCH 4 - PROGRESS: at 82.56% examples, 245368 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:42,124 : INFO : EPOCH 4 - PROGRESS: at 85.34% examples, 247963 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:09:43,142 : INFO : EPOCH 4 - PROGRESS: at 88.52% examples, 251479 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:44,149 : INFO : EPOCH 4 - PROGRESS: at 91.32% examples, 253803 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:45,173 : INFO : EPOCH 4 - PROGRESS: at 94.60% examples, 257163 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:46,197 : INFO : EPOCH 4 - PROGRESS: at 97.62% examples, 259774 words/s, in_qsize 7, out_qsize 2
2018-04-30 12:09:46,892 : INFO : worker thread finished; awaiting finish of 3 more threads
2018-04-30 12:09:46,915 : INFO : worker thread finished; awaiting finish of 2 more threads
2018-04-30 12:09:46,920 : INFO : worker thread finished; awaiting finish of 1 more threads
2018-04-30 12:09:46,929 : INFO : worker thread finished; awaiting finish of 0 more threads
2018-04-30 12:09:46,930 : INFO : EPOCH - 4 : training on 17798270 raw words (12873324 effective words) took 49.1s, 262219 effective words/s
2018-04-30 12:09:47,958 : INFO : EPOCH 5 - PROGRESS: at 3.13% examples, 399629 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:48,990 : INFO : EPOCH 5 - PROGRESS: at 6.40% examples, 402616 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:50,001 : INFO : EPOCH 5 - PROGRESS: at 9.75% examples, 408700 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:51,010 : INFO : EPOCH 5 - PROGRESS: at 12.57% examples, 396184 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:52,024 : INFO : EPOCH 5 - PROGRESS: at 15.84% examples, 399643 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:53,087 : INFO : EPOCH 5 - PROGRESS: at 19.04% examples, 396274 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:54,098 : INFO : EPOCH 5 - PROGRESS: at 22.20% examples, 396805 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:55,102 : INFO : EPOCH 5 - PROGRESS: at 25.40% examples, 398372 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:56,121 : INFO : EPOCH 5 - PROGRESS: at 28.70% examples, 400506 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:57,133 : INFO : EPOCH 5 - PROGRESS: at 32.02% examples, 401787 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:09:58,149 : INFO : EPOCH 5 - PROGRESS: at 35.21% examples, 402060 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:09:59,155 : INFO : EPOCH 5 - PROGRESS: at 38.63% examples, 405073 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:00,174 : INFO : EPOCH 5 - PROGRESS: at 41.86% examples, 405512 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:01,211 : INFO : EPOCH 5 - PROGRESS: at 44.84% examples, 402875 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:10:02,215 : INFO : EPOCH 5 - PROGRESS: at 47.56% examples, 399532 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:03,254 : INFO : EPOCH 5 - PROGRESS: at 50.10% examples, 394475 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:04,259 : INFO : EPOCH 5 - PROGRESS: at 52.83% examples, 391585 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:05,269 : INFO : EPOCH 5 - PROGRESS: at 56.16% examples, 393617 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:06,270 : INFO : EPOCH 5 - PROGRESS: at 59.39% examples, 395269 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:07,284 : INFO : EPOCH 5 - PROGRESS: at 62.43% examples, 394699 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:08,298 : INFO : EPOCH 5 - PROGRESS: at 65.68% examples, 395585 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:09,304 : INFO : EPOCH 5 - PROGRESS: at 69.03% examples, 397157 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:10,319 : INFO : EPOCH 5 - PROGRESS: at 71.76% examples, 395053 words/s, in_qsize 6, out_qsize 1
2018-04-30 12:10:11,325 : INFO : EPOCH 5 - PROGRESS: at 74.68% examples, 394162 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:12,345 : INFO : EPOCH 5 - PROGRESS: at 77.94% examples, 394830 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:13,375 : INFO : EPOCH 5 - PROGRESS: at 81.37% examples, 396089 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:14,393 : INFO : EPOCH 5 - PROGRESS: at 84.51% examples, 396105 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:15,406 : INFO : EPOCH 5 - PROGRESS: at 87.64% examples, 396246 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:16,418 : INFO : EPOCH 5 - PROGRESS: at 90.71% examples, 396094 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:17,418 : INFO : EPOCH 5 - PROGRESS: at 93.74% examples, 395884 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:18,419 : INFO : EPOCH 5 - PROGRESS: at 96.69% examples, 395222 words/s, in_qsize 7, out_qsize 0
2018-04-30 12:10:19,426 : INFO : EPOCH 5 - PROGRESS: at 99.44% examples, 394099 words/s, in_qsize 8, out_qsize 0
2018-04-30 12:10:19,516 : INFO : worker thread finished; awaiting finish of 3 more threads
2018-04-30 12:10:19,536 : INFO : worker thread finished; awaiting finish of 2 more threads
2018-04-30 12:10:19,547 : INFO : worker thread finished; awaiting finish of 1 more threads
2018-04-30 12:10:19,552 : INFO : worker thread finished; awaiting finish of 0 more threads
2018-04-30 12:10:19,553 : INFO : EPOCH - 5 : training on 17798270 raw words (12871972 effective words) took 32.6s, 394752 effective words/s
2018-04-30 12:10:19,555 : INFO : training on a 88991350 raw words (64362962 effective words) took 202.0s, 318637 effective words/s





<gensim.models.word2vec.Word2Vec at 0x23f36bbac18>

# 학습이 완료 되면 필요없는 메모리를 unload 시킨다.
model.init_sims(replace=True)

model_name = '300features_40minwords_10text'
# model_name = '300features_50minwords_20text'
model.save(model_name)

2018-04-30 12:10:19,865 : INFO : precomputing L2-norms of word weight vectors
2018-04-30 12:10:20,082 : INFO : saving Word2Vec object under 300features_40minwords_10text, separately None
2018-04-30 12:10:20,099 : INFO : not storing attribute vectors_norm
2018-04-30 12:10:20,118 : INFO : not storing attribute cum_table
2018-04-30 12:10:21,103 : INFO : saved 300features_40minwords_10text

# 유사도가 없는 단어 추출
model.wv.doesnt_match('man woman child kitchen'.split())

'kitchen'

model.wv.doesnt_match("france england germany berlin".split())

2018-04-30 12:10:21,386 : WARNING : vectors for words {'germany', 'france'} are not present in the model, ignoring these words

'england'

# 가장 유사한 단어를 추출
model.wv.most_similar("man")

[('woman', 0.6355543732643127),
 ('businessman', 0.5106414556503296),
 ('lad', 0.49627137184143066),
 ('millionair', 0.4852792024612427),
 ('ladi', 0.48219048976898193),
 ('policeman', 0.47352561354637146),
 ('widow', 0.4686756134033203),
 ('farmer', 0.4667765200138092),
 ('men', 0.4604969620704651),
 ('boxer', 0.4499785602092743)]

model.wv.most_similar("queen")

[('princess', 0.6181148886680603),
 ('madam', 0.5621399283409119),
 ('latifah', 0.5599690675735474),
 ('countess', 0.557962954044342),
 ('dame', 0.5570350885391235),
 ('stepmoth', 0.554591178894043),
 ('victoria', 0.5522404909133911),
 ('maid', 0.5426138639450073),
 ('maria', 0.533758282661438),
 ('eva', 0.5325278639793396)]

# model.wv.most_similar("happy")
model.wv.most_similar("happi") # stemming 처리 시

[('unhappi', 0.45206087827682495),
 ('sad', 0.43361160159111023),
 ('bitter', 0.40061312913894653),
 ('satisfi', 0.3947785198688507),
 ('lucki', 0.3823172450065613),
 ('joy', 0.37378984689712524),
 ('happier', 0.36996692419052124),
 ('glad', 0.3682306408882141),
 ('sappi', 0.36718422174453735),
 ('afraid', 0.3600339889526367)]

# 참고 https://stackoverflow.com/questions/43776572/visualise-word2vec-generated-from-gensim
from sklearn.manifold import TSNE
import matplotlib as mpl
import matplotlib.pyplot as plt
import gensim
import gensim.models as g

# 그래프에서 마이너스 폰트 깨지는 문제에 대한 대처
mpl.rcParams['axes.unicode_minus'] = False

model_name = '300features_40minwords_10text'
model = g.Doc2Vec.load(model_name)

vocab = list(model.wv.vocab)
X = model[vocab]

print(len(X))
print(X[0][:10])
tsne = TSNE(n_components=2)

# 100개의 단어에 대해서만 시각화
X_tsne = tsne.fit_transform(X[:100,:])
# X_tsne = tsne.fit_transform(X)

2018-04-30 12:10:26,511 : INFO : loading Doc2Vec object from 300features_40minwords_10text
2018-04-30 12:10:26,982 : INFO : loading wv recursively from 300features_40minwords_10text.wv.* with mmap=None
2018-04-30 12:10:26,983 : INFO : setting ignored attribute vectors_norm to None
2018-04-30 12:10:26,984 : INFO : loading vocabulary recursively from 300features_40minwords_10text.vocabulary.* with mmap=None
2018-04-30 12:10:26,985 : INFO : loading trainables recursively from 300features_40minwords_10text.trainables.* with mmap=None
2018-04-30 12:10:26,986 : INFO : setting ignored attribute cum_table to None
2018-04-30 12:10:26,987 : INFO : loaded 300features_40minwords_10text
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:15: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).
  from ipykernel import kernelapp as app


11986
[-0.04888876  0.02344336 -0.11825124 -0.0108145  -0.02040573  0.09992806
 -0.01389777 -0.02648932 -0.07141103 -0.03799058]

df = pd.DataFrame(X_tsne, index=vocab[:100], columns=['x', 'y'])
df.shape

(100, 2)

df.head(10)

	x	y
with	-12.056787	4.115122
all	-2.497947	5.160569
this	-3.791062	4.612969
stuff	-2.408651	-1.128544
go	-9.874672	0.933419
down	-11.559048	7.447039
at	-10.873740	5.436837
the	-2.758157	6.790027
moment	0.124072	2.817021
mj	3.170858	-2.268975

fig = plt.figure()
fig.set_size_inches(40, 20)
ax = fig.add_subplot(1, 1, 1)

ax.scatter(df['x'], df['y'])

for word, pos in df.iterrows():
    ax.annotate(word, pos, fontsize=30)
plt.show()

import numpy as np

def makeFeatureVec(words, model, num_features):
    """
    주어진 문장에서 단어 벡터의 평균을 구하는 함수
    """
    # 속도를 위해 0으로 채운 배열로 초기화 한다.
    featureVec = np.zeros((num_features,),dtype="float32")

    nwords = 0.
    # Index2word는 모델의 사전에 있는 단어명을 담은 리스트이다.
    # 속도를 위해 set 형태로 초기화 한다.
    index2word_set = set(model.wv.index2word)
    # 루프를 돌며 모델 사전에 포함이 되는 단어라면 피처에 추가한다.
    for word in words:
        if word in index2word_set:
            nwords = nwords + 1.
            featureVec = np.add(featureVec,model[word])
    # 결과를 단어수로 나누어 평균을 구한다.
    featureVec = np.divide(featureVec,nwords)
    return featureVec

def getAvgFeatureVecs(reviews, model, num_features):
    # 리뷰 단어 목록의 각각에 대한 평균 feature 벡터를 계산하고
    # 2D numpy 배열을 반환한다.

    # 카운터를 초기화 한다.
    counter = 0.
    # 속도를 위해 2D 넘파이 배열을 미리 할당한다.
    reviewFeatureVecs = np.zeros(
        (len(reviews),num_features),dtype="float32")

    for review in reviews:
       # 매 1000개 리뷰마다 상태를 출력
       if counter%1000. == 0.:
           print("Review %d of %d" % (counter, len(reviews)))
       # 평균 피처 벡터를 만들기 위해 위에서 정의한 함수를 호출한다.
       reviewFeatureVecs[int(counter)] = makeFeatureVec(review, model, \
           num_features)
       # 카운터를 증가시킨다.
       counter = counter + 1.
    return reviewFeatureVecs

# 멀티스레드로 4개의 워커를 사용해 처리한다.
def getCleanReviews(reviews):
    clean_reviews = []
    clean_reviews = kaggleBagofWord.apply_by_multiprocessing(\
        reviews["review"], kaggleBagofWord.review_to_wordlist,\
        workers=4)
    return clean_reviews

%time trainDataVecs = getAvgFeatureVecs(\
    getCleanReviews(train), model, num_features )

Review 0 of 25000


C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:18: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).


Review 1000 of 25000
Review 2000 of 25000
Review 3000 of 25000
Review 4000 of 25000
Review 5000 of 25000
Review 6000 of 25000
Review 7000 of 25000
Review 8000 of 25000
Review 9000 of 25000
Review 10000 of 25000
Review 11000 of 25000
Review 12000 of 25000
Review 13000 of 25000
Review 14000 of 25000
Review 15000 of 25000
Review 16000 of 25000
Review 17000 of 25000
Review 18000 of 25000
Review 19000 of 25000
Review 20000 of 25000
Review 21000 of 25000
Review 22000 of 25000
Review 23000 of 25000
Review 24000 of 25000
Wall time: 2min 43s

%time testDataVecs = getAvgFeatureVecs(\
        getCleanReviews(test), model, num_features )

Review 0 of 25000


C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:18: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).


Review 1000 of 25000
Review 2000 of 25000
Review 3000 of 25000
Review 4000 of 25000
Review 5000 of 25000
Review 6000 of 25000
Review 7000 of 25000
Review 8000 of 25000
Review 9000 of 25000
Review 10000 of 25000
Review 11000 of 25000
Review 12000 of 25000
Review 13000 of 25000
Review 14000 of 25000
Review 15000 of 25000
Review 16000 of 25000
Review 17000 of 25000
Review 18000 of 25000
Review 19000 of 25000
Review 20000 of 25000
Review 21000 of 25000
Review 22000 of 25000
Review 23000 of 25000
Review 24000 of 25000
Wall time: 2min 28s

from sklearn.ensemble import RandomForestClassifier

forest = RandomForestClassifier(
    n_estimators = 100, n_jobs = -1, random_state=2018)

%time forest = forest.fit( trainDataVecs, train["sentiment"] )

Wall time: 21.1 s

from sklearn.model_selection import cross_val_score
%time score = np.mean(cross_val_score(\
    forest, trainDataVecs, \
    train['sentiment'], cv=10, scoring='roc_auc'))

Wall time: 3min 18s

score

0.904642208

result = forest.predict( testDataVecs )

output = pd.DataFrame( data={"id":test["id"], "sentiment":result} )
output.to_csv('data/Word2Vec_AverageVectors_{0:.5f}.csv'.format(score),
              index=False, quoting=3 )

output_sentiment = output['sentiment'].value_counts()
print(output_sentiment[0] - output_sentiment[1])
output_sentiment

66

0    12533
1    12467
Name: sentiment, dtype: int64

import seaborn as sns
%matplotlib inline

fig, axes = plt.subplots(ncols=2)
fig.set_size_inches(12,5)
sns.countplot(train['sentiment'], ax=axes[0])
sns.countplot(output['sentiment'], ax=axes[1])

<matplotlib.axes._subplots.AxesSubplot at 0x1681f5faa90>

Score 81.34%

CNN을 활용한 주요 Model - (1) : Modern CNN

2018-06-27T04:47:35+00:00

CNN을 활용한 주요 Model - (1) : Modern CNN

Modern CNN
- LeNet
- AlexNet
- VGG Nets
- GoogLeNet
- ResNet
Image Detection
- RCNN
- Fast RCNN
- Faster RCNN
- SPP Net
- Yolo
- SDD
- Attention Net
Semantic Segmentation
- FCN
- DeepLab v1, v2
- U-Net
- ReSeg
Image Captioning

LeNet

지난 포스트에서 얘기한 것 처럼 CNN 모델을 최초로 개발한 사람은 프랑스 출신의 Yann LeCun이며, 1989년 “Backpropagation applied to handwritten zip code recognition” 논문을 통해 최초로 CNN을 사용하였고, 이후 1998년 LeNet이라는 Network를 소개하였다.

LeNet은 우편번호와 수표의 필기체를 인식하기 위해 개발되었다. LeNet의 최종 모델인 LeNet5의 Architecture를 보면 아래와 같이 이루어져

LeNet 5는 총 7개의 Layer로 구성되어 있다. 두개의 Convolution Layer, 2개의 Sub-Sampling Layer, 2개의 Fully-Connected Layer 그리고 최종 출력 Layer로 이루어져 있다.

LeNet에 대한 자세한 내용은 LeNet Post를 참고하면 된다.

AlexNet

보통 CNN을 얘기할 때 가장 먼저 얘기되는 AlexNet은 2012년 저명한 Computer Vision 대회인 ILSVRC(ImageNet Large-Scale Visual Recognition Challenge)에서 2등(26.2%)보다 월등히 앞서 1등(15.4%)을 하며 소개되었다. 이렇게 월등히 높은 top-5 error로 세상은 CNN에 대해 주목을 하게 된 계기가 되었다.

AlexNet의 Architecture는 아래와 같다. 구성은

5 Conv layer
max polling layer
drop out layer
3 FC layer

으로 이루어졌으며 병렬 구조를 이루고 있다.

AlexNet의 주요 포인트는 아래와 같다.

22000이상의 Categories를 가지는 1500만개 이상의 ImageNet data를 사용하였다.
비선형 함수인 ReLU를 사용하였다.(기존의 tanh함수를 사용할때 보다 ReLu를 사용하면서 학습시간이 줄었다)
Data Augmentation 기술을 사용하였다(Image translation/Horizontal reflections/Patch extraction)
모델 최적화시 SGD를 사용하였고 가중지 감소와 모멘텀 기술을 사용했다.
GTX 580을 사용해 5~6일 동안 학습하였다.

VGG Net

AlexNet이후의 모델들에게 있어 가장 중요한 쟁점은 얼마나 더 Deep하게 모델을 만드는가 였다. 그런 Deep한 대표적인 모델이 VGG Net과 GoogLeNet이다. VGG의 특징은 간단한 구조로 사용하기 쉽다는 점이다. 모든 Conv layer는 3x3filter를 동일하게 사용하고 1stride, 1pad를 사용한다. Sub-Sampling은 2x2 Max Polling을 2stride로 이뤄진다. 구조를 그림으로 보자.

VGG Net의 주요포인트는 다음과 같다

AlexNet의 11x11 filter와 ZFNet의 7x7 filter를 사용한 것과는 달리 VGG Net은 3x3 filter를 사용하였다. 뿐만 아니라 3x3 filter를 Convolution하는 layer를 두개씩 연이어 사용했다. 3x3 filter를 두번 사용함으로써 5x5 filter receptive field를 얻는것과 같은 효과를 얻는다.
3개의 연이은 conv layer를 통해 7x7 receptive field를 갖는 효과를 얻는다.
max-pooling layer에서 input volume을 줄임으로써 network를 깊게 만든다.
VGG Net을 통해 Image Classification과 Localization Task 둘다에 사용하였다.(Localization은 마지막 단에서 Regression을 사용하였다. Paper참고)
Data Augmentation을 위해 scale jittering를 사용하였다.
각 conv layer이후 ReLU함수를 사용하였고, batch gradient descent를 사용했다.
NVidia Titan Black GPU 4개를 사용해 2~3주간 학습했다.

GoogLeNet

2014년 ILSVRC에서 Google은 GoogLeNet으로 VGG를 재치고 근소한 차이로 1등을 차지하게 된다. 이때부터의 모델들이 주목하던 부분은 얼마나 깊게(Deep) 모델을 만드는 것이다. 기존의 filter를 여러개 사용하던 LeNet, AlexNet과는 달리 하나의 Conv Layer에서 1개의 filter만 사용되었다. 우선 기본 architecture부터 살펴보면 이전의 model들 보다는 훨씬 더 깊다는 것을 한눈에 알 수 있다. 총 22개의

GoogLeNet에서 사용된 가장 중요한 기술은 Inception-module 을 사용했다는 점이다. Inception module을 사용함으로써 Parameter 수를 획기적으로 줄였으며, 다양한 receptive field를 가지는 convolution들을 concatenate함으로써 이미지 인식률을 높였다.

GoogLeNet의 주요 포인트은 아래와 같다.

9개의 Inception modules을 사용하면서 총 100개가 넘는 깊은 network를 가진다.
FC layer를 사용하지않고 average pooling을 사용해 7x7x1024를 1x1x1024로 만들었다. 이과정을 통해 파라미터 수를 획기적으로 줄였다.
R-CNN concept를 사용하였다(for detection model)
Inception model은 계속해서 Update되었다(~7)
학습은 GPU를 활용해 한주동안 하였다.

ResNet

이전까지의 AlexNet이후의 Model들은 모델들을 깊게 쌓음으로써 높은 인식률을 보여줬다. 하지만 깊게 쌓으면서 몇 가지 문제가 발생했다.

Vanishing/Exploding Gradient : Parameter학습 시 gradient값이 너무 크거나 작아서 학습이 제대로 이뤄지지 않는 문제이다. 보통 Batch Normalization, parameter 초기값 설정 등으로 해결 하지만 layer가 깊어질 수록 해결이 어렵다.
Degeneration : depth를 깊게 쌓으면서 일정 깊이 이상 넘어갈 시 성능이 더 좋아지지 않는 문제.

ResNet은 이러한 문제를 Residual Block을 통해 해결 하고 ILSVRC 2015에서 3.6%의 error 라는 놀라울 결과를 보여주었다.

Residual Block Residual Block은 input에 대해 layer를 통과시킨 값($F(x)$)을 바로 다음 단으로 통과시키는 것이 아니라 Input값을 더해서 다음 단으로 통과시킨다.($F(x)+x$) 이러한 구조를 통해 저자는 학습이 훨씬 쉬워졌다고 말한다. 또한 Back propagation과정에서 gradient값이 $x$를 더함으로써 더욱 이전 단으로 잘 전달된다.

나머지 Model들에 대해서는 다음 포스트에서 계속해서 알아보도록 하겠다.

출처

LeNet

2018-06-27T04:47:35+00:00

LeNet

CNN 모델을 최초로 개발한 사람은 프랑스 출신의 Yann LeCun이며, 1989년 “Backpropagation applied to handwritten zip code recognition” 논문을 통해 최초로 CNN을 사용하였고, 이후 1998년 LeNet이라는 Network를 소개하였다.

LeNet은 우편번호와 수표의 필기체를 인식하기 위해 개발되었다. LeNet의 최종 모델인 LeNet5의 Architecture를 보면 아래와 같이 이루어져

LeNet 5는 총 7개의 Layer로 구성되어 있다. 두개의 Convolution Layer, 2개의 Sub-Sampling Layer, 2개의 Fully-Connected Layer 그리고 최종 출력 Layer로 이루어져 있다.

1-layer : Convolution Layer Input Data(32x32, 1개의 Channel)를 5x5 Filter 6개를 사용해 Convolution한다. 그결과로는 28x28 사이즈의 Feature map을 6개 만들어 낸다. Parameter의 수는 아래와 같다. 5x5 filter 6개, bias 6개 => $556+1*6=156$
2-layer : SubSampling Layer 28x28의 feature map에 대해 2x2size의 receptive field로 Average Pooling을 시행한다. 따라서 14x14 size를 6개 만든다.
3-layer : Convolution layer2 Conv layer1과 동일하게 5x5 Filter 16개를 사용해 총 10x10 feature map 16개를 만들어 낸다. 일반적으로 수행한다면 6x16 인 96개의 feature map이 만들어져야 하지만 여기서는 모든 map을 연결 하는 것이 아니라 아래의 Table과 같이 선택적으로 연결시켜 network의 symmetry한 성질을 없애려는 것으로 볼 수 있다. 최종적으로 Global feature를 얻기 위함이다.
파라미터 수는 $5560+1*16=1,516$개다.
4-layer : SubSampling layer2 subsmapling1 layer와 마찬가지로 2x2 receptive field에 대해서 average polling을 시행한다.
5-layer : FC layer 5x5 filter 120개를 사용해 1x1 feature map 120개를 만든다 파라미터의 수는 $551920+1*120$개가 된다.
6-layer : FC layer2 1x1x120 date를 1x1x84개의 data로 만든다. 파라미터 수는 $120x84+1*84$개 이다.
7-layer :

About CNN

2018-06-27T04:47:35+00:00

About CNN

CNN의 역사

CNN이 최초로 등장한 것은 1989년 LeCun의 “Backpropagation applied to handwritten zip code recognition” 에서 처음으로 등장하였다. CNN을 활용해 필기체 인식에서 성과를 확인하였지만, 이를 범용화 하기에는 아직까지는 어려움이 많이있었다. LeCun은 이후 LeNet이라는 Network를 1998년 처음으로 소개하게 되었다.

이후 2003년 Behnke의 논문 “Hierarchical Neural Networks for Image Interpretation” 과 simard의 논문 “Best Practices for Convolutional Neural Networks Applied to Visual Document Analysis” 을 통해 일반화과 되었다고 볼 수 있다.

Image에서 CNN을 도입한데에는 기존의 Fully-Connected Neural Network들이 Image에 적용할 경우 똑같은 Object를 나타내더라도 조금만 변형(ex. 기울어짐, 비틀림 등)이 일어나도 다른 Object로 인식을 할 수 있다는 단점이 존재했기 떄문이다.(Image의 Topology 변화에 대응이 어렵다)

About CNN

CNN은 기본적으로 Image에 대해 Convolution 연산을 사용하는 layer들이 사용된 Neural Network를 뜻한다.

CNN의 기본적인 구조는 아래와 같다. CNN의 기본적인 Architecture (출처 : https://taewanmerepo.github.io/2018/01/cnn/cnnexam.png)

Convolution Layer와 Sub-Sampling Layer들이 일정 수 만큼 나온 후 마지막에 Fully-Connected Layer가 나오는 구조이다.

CNN의 주요 용어

CNN에서 주로 사용되는 사용되는 용어는 아래와 같다.

Convolution
Channel
Filter
Kernel
Stride
Padding
Fiture Map
Activation Map
Polling

Convolution CNN에서의 합성곱이란 각각의 Pixel에 대해 일정한 값들을 곱한 후 합치는 과정을 의미한다. 아래의 그림과 같이 Convolution 연산이 이뤄진다. 합성곱 연산 (출처: http://deeplearning.stanford.edu/wiki/index.php/Feature_extraction_using_convolution)
Channel Image의 층으로 이해할 수 있다. 기본적으로 흑백이 아닌 컬러사진은 각 픽셀에 대해 RGB값이 3개의 Value를 갖는다. 따라서 컬러 사진은 3개의 채널을 가지게 된다. Channel (출처:https://en.wikipedia.org/wiki/Channel_(digital_image))
Filter Filter는 Convolution 연산이 이뤄지는 window를 의미한다.
Kernel CNN에서 Kernel은 Filter와 같은 의미로 사용된다.
Stride Convolution Layer에서 기본적으로는 filter가 한칸씩 이동하면 Convolution 연산이 이뤄지지만, Stride 값에 따라 Convolution연산을 한 뒤 n칸만큼 이동한 후 Convolution 연산이 이뤄진다. 그림을 통해 이해하면 쉽다. (출처:https://taewanmerepo.github.io/2018/01/cnn/filter.jpg)
Padding Padding이란 Convolution Layer에서 이미지의 가장자리에 일정한 값을 추가로 넣는 것을 의미한다 주로 Zero Padding이 사용된다.
Fiture Map Convolution 결과로 만들어진 Map을 의미한다.
Activation Map Filter Map에 Activation Fuction을 적용한 Map을 의미한다.
Polling Polling 이란 Fiture Map의 크기를 줄이기 위해 주로 사용한다. 일정한 크기의 영역의 값들을 어떠한 특징으로 값을 뽑아 하나의 값으로 줄이는 과정이다 (출처 : https://taewanmerepo.github.io/2018/02/cnn/maxpulling.png)

CNN을 활용한 Computer Vision 문제들

초기에는 필기체 숫자들을 분류하기 위해 CNN을 사용하였지만, 시간이 흐르면서 점점 많은 분야에 CNN이 활용되고 있다.

CNN이 사용되는 대표적인 Task들을 다음과 같다

Image Classification
Semantic Segmentation
Object Detection
Object Localization
Visual QnA
Image Captioning

이러한 Task들을 풀어가는 CNN 모델들에 대해서 다음 포스트에서 하나씩 알아보도록 하겠다.

Tensorflow Tutorial - Image Recognition

2018-06-18T04:47:35+00:00

Image Recognition

(이 문서는 Tensorflow의 공식 tutorial 가이드를 따라한 것입니다. (Tensorflow tutorial)

사람의 뇌는 어떠한 사진을 보고 사자인지, 표범인지 구별하거나, 사람의 얼굴의 인식하는 것을 매우 쉽게 한다. 그러나 이러한 일들은 컴퓨터에게는 쉽지 않은 일이다. 지난 몇년동안 이러한 분야에서 machine learning 은 많은 성과를 이뤘다. CNN 모델을 통해 우리는 visual recognition 분야에서 reasonable한 perfomance를 보여줬다.

많은 연구들은 computer vision분야에서 학문적인 기준점이 되는 ImageNet에 대해 계속해서 발전해나가는 연구들을 선보였다. 이후 많은 연구들이 계속해서 state-of-art한 성과를 보여줬다. : QuocNet, AlexNet, Inception (GoogLeNet), BN-Inception-v2 이후에도 계속해서 Google은 많은 논문들을 작성하고 기존의 모델들을 수정해 새롭게 공개했다. 그 중 우리는 가장 최근 모델인 Inception-v3에 대해서 알아보겠다.

Inception-v3 모델은 ImageNet(2012년 부터 진행된 같은 데이터를 사용하는 Visual Recognition Challenge), Computer vision분야에서 가장 기본적인 task는 전체 이미지를 1000개의 class로 구분하는 문제이다.(ex. “Zebra”, “Dalmation”, “Dishwasher”), 예를 들면 아래의 결과는 AlexNet이 Classify한 결과이다.

모델들을 비교하기 위해 각 모델들이 top 5 guesses에 대해 얼마나 예측을 실패 한지를 비교하였다.(top-5 error rate)

AlexNet : 15.3%
Inception (GoogLeNet) : 6.67%
BN-Inception-v2 : 4.9%
Inception-v3 : 3.46%

이번 Tutorial에서는 Inception-v3 model을 사용하는 방법에 대해서 배울 것이다. Python 또는 C++ 에서 1000개의 클래스들로 분류하는 방법에 대해서 배워 볼 것이다.

Usage with Python API

classify_image.py 파일을 이곳에서 다운받는다. 코드 전문을 보면,

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import os.path
import re
import sys
import tarfile

import numpy as np
from six.moves import urllib
import tensorflow as tf

FLAGS = None

# pylint: disable=line-too-long
DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'
# pylint: enable=line-too-long


class NodeLookup(object):
  """Converts integer node ID's to human readable labels."""

  def __init__(self,
               label_lookup_path=None,
               uid_lookup_path=None):
    if not label_lookup_path:
      label_lookup_path = os.path.join(
          FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt')
    if not uid_lookup_path:
      uid_lookup_path = os.path.join(
          FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt')
    self.node_lookup = self.load(label_lookup_path, uid_lookup_path)

  def load(self, label_lookup_path, uid_lookup_path):
    """Loads a human readable English name for each softmax node.
    Args:
      label_lookup_path: string UID to integer node ID.
      uid_lookup_path: string UID to human-readable string.
    Returns:
      dict from integer node ID to human-readable string.
    """
    if not tf.gfile.Exists(uid_lookup_path):
      tf.logging.fatal('File does not exist %s', uid_lookup_path)
    if not tf.gfile.Exists(label_lookup_path):
      tf.logging.fatal('File does not exist %s', label_lookup_path)

    # Loads mapping from string UID to human-readable string
    proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()
    uid_to_human = {}
    p = re.compile(r'[n\d]*[ \S,]*')
    for line in proto_as_ascii_lines:
      parsed_items = p.findall(line)
      uid = parsed_items[0]
      human_string = parsed_items[2]
      uid_to_human[uid] = human_string

    # Loads mapping from string UID to integer node ID.
    node_id_to_uid = {}
    proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines()
    for line in proto_as_ascii:
      if line.startswith('  target_class:'):
        target_class = int(line.split(': ')[1])
      if line.startswith('  target_class_string:'):
        target_class_string = line.split(': ')[1]
        node_id_to_uid[target_class] = target_class_string[1:-2]

    # Loads the final mapping of integer node ID to human-readable string
    node_id_to_name = {}
    for key, val in node_id_to_uid.items():
      if val not in uid_to_human:
        tf.logging.fatal('Failed to locate: %s', val)
      name = uid_to_human[val]
      node_id_to_name[key] = name

    return node_id_to_name

  def id_to_string(self, node_id):
    if node_id not in self.node_lookup:
      return ''
    return self.node_lookup[node_id]


def create_graph():
  """Creates a graph from saved GraphDef file and returns a saver."""
  # Creates graph from saved graph_def.pb.
  with tf.gfile.FastGFile(os.path.join(
      FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())
    _ = tf.import_graph_def(graph_def, name='')


def run_inference_on_image(image):
  """Runs inference on an image.
  Args:
    image: Image file name.
  Returns:
    Nothing
  """
  if not tf.gfile.Exists(image):
    tf.logging.fatal('File does not exist %s', image)
  image_data = tf.gfile.FastGFile(image, 'rb').read()

  # Creates graph from saved GraphDef.
  create_graph()

  with tf.Session() as sess:
    # Some useful tensors:
    # 'softmax:0': A tensor containing the normalized prediction across
    #   1000 labels.
    # 'pool_3:0': A tensor containing the next-to-last layer containing 2048
    #   float description of the image.
    # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG
    #   encoding of the image.
    # Runs the softmax tensor by feeding the image_data as input to the graph.
    softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')
    predictions = sess.run(softmax_tensor,
                           {'DecodeJpeg/contents:0': image_data})
    predictions = np.squeeze(predictions)

    # Creates node ID --> English string lookup.
    node_lookup = NodeLookup()

    top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]
    for node_id in top_k:
      human_string = node_lookup.id_to_string(node_id)
      score = predictions[node_id]
      print('%s (score = %.5f)' % (human_string, score))


def maybe_download_and_extract():
  """Download and extract model tar file."""
  dest_directory = FLAGS.model_dir
  if not os.path.exists(dest_directory):
    os.makedirs(dest_directory)
  filename = DATA_URL.split('/')[-1]
  filepath = os.path.join(dest_directory, filename)
  if not os.path.exists(filepath):
    def _progress(count, block_size, total_size):
      sys.stdout.write('\r>> Downloading %s %.1f%%' % (
          filename, float(count * block_size) / float(total_size) * 100.0))
      sys.stdout.flush()
    filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)
    print()
    statinfo = os.stat(filepath)
    print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')
  tarfile.open(filepath, 'r:gz').extractall(dest_directory)


def main(_):
  maybe_download_and_extract()
  image = (FLAGS.image_file if FLAGS.image_file else
           os.path.join(FLAGS.model_dir, 'cropped_panda.jpg'))
  run_inference_on_image(image)


if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  # classify_image_graph_def.pb:
  #   Binary representation of the GraphDef protocol buffer.
  # imagenet_synset_to_human_label_map.txt:
  #   Map from synset ID to a human readable string.
  # imagenet_2012_challenge_label_map_proto.pbtxt:
  #   Text representation of a protocol buffer mapping a label to synset ID.
  parser.add_argument(
      '--model_dir',
      type=str,
      default='/tmp/imagenet',
      help="""\
      Path to classify_image_graph_def.pb,
      imagenet_synset_to_human_label_map.txt, and
      imagenet_2012_challenge_label_map_proto.pbtxt.\
      """
  )
  parser.add_argument(
      '--image_file',
      type=str,
      default='',
      help='Absolute path to image file.'
  )
  parser.add_argument(
      '--num_top_predictions',
      type=int,
      default=5,
      help='Display this many predictions.'
  )
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

Tensorflow Tutorial - Image Retraining

2018-06-18T04:45:35+00:00

Image Retraining

How to Retrain an Image Classifier for New Categories

(이 문서는 Tensorflow의 공식 tutorial 가이드를 따라한 것입니다. (Tensorflow tutorial)

현대의 image recognition model들은 수백만개의 파라미터들을 가지고 있다. 막대한 양의 파라미터들을 처음부터 그냥 학습시키는것은 엄청난 양의 computer power를 필요로 한다. Transer Learning 은 우리의 task와 연관된 pre-trained 모델들을 사용함으로써 계산량을 줄이는 손쉬운 방법이다. 이번 튜토리얼에서는 ImageNet으로 학습된 강력한 Image Classifier를 통해 feature extraction을 재사용한 후 상단의 classification layer를 학습해보도록 할 것이다. 더 많은 정보는 DeCAF : A Deep Convolutional Activation Feature for Generic Visual Recognition을 통해 보면 된다.

전체 모델을 새롭게 학습하는 것보다는 좋지는 않지만, 이러한 방법은 놀랍게도 많은 Applications, Works(적당한 양의, 수천개의 Trainning data)에서 효과적이고, 이것은 GPU없이 노트북에서도 삼십분정도면 실행시킬 수 있다. 이번 tutorial에서 각자 자신의 image를 가지고 예제를 실행하는 방법에 대해서 알아볼 것이며, 학습과정을 제어할 수 있는 몇 가지 옵션에 대해서 알아볼 것이다.

NOTE 이번 튜토리얼은 Codelab에서도 실행 가능하다.

이번 tutorial에서 흔히 Module 이라 불리는 사전 학습된 모델들을 사용할 것이다. 처음으로 우리는 Image feature extraction module 모델을 사용한다. 이 모델을 inception V3 아키텍쳐를 가지며, ImageNet을 사전 학습했다. 그 후에는 더 많은 옵션(NASNet/PNASNet, Mobile NET V1, V2)들을 학습할 것이다.

시작하기 전에, tensorflow-hub PIP package를 설치해야 한다. 설치에 대한 자세한 사항은 Installation instructions참고

Trainning On Flowers

Image by Kelly Sikkema

학습을 시작하기 전 우리는 우리가 인식하고 싶어하는 새로운 클래스의 사진들이 필요할 것이다. 이후에 각자 자신들의 사진으로 학습하는 방법을 배워보고, 그전에 먼저 CC LICENSE인 Flower 사진들을 가지고 학습을 해보도록 하겠다. 사진을 가져오기 위해 아래 명령어를 실행하자.

cd ~
curl -LO http://download.tensorflow.org/example_images/flower_photos.tgz
tar xzf flower_photos.tgz
// 윈도우의 경우에는 직접 압축을 풀자

사진을 받았다면, 우리가 필요한 code를 github에서 clone 하자.

mkdir ~/example_code
cd ~/example_code
curl -LO https://github.com/tensorflow/hub/raw/r0.1/examples/image_retraining/retrain.py

이후 retrainner 파일을 실행하자, 컴퓨터마다 다르겟지만 30분정도 소요된다.

python retrain.py --image_dir ~/flower_photos

뿐만 아니라 수많은 옵션들을 확인해보자,

python retrain.py -h

위의 retrain.py 파일은 방금 다운받은 Flower사진들로 network을 재학습시킬 것이다. 참고로 위의 Flower 사진들은 pre-trained시킨 data인 ImageNet에는 전혀 들어가 있지 않은 사진들이다.

Bottlenecks

위의 프로그램을 실행하면, 가장 먼저 사진들에 대해 분석하고, 계산해서 저장하는 값들은 bottleneck값이 된다. ‘Bottleneck’이란 실제 분류가 진행되는 마지막 층(Final output layer) 이전의 layer를 지칭하는 비공식적인 용어이다.(Tensorflow Hub은 이를 “image feature vector”라 부른다) 위의 뒤에서 두번째 레이어는 인식하려하는 클래스들을 충분히 잘 구별할 수 있게 output값을 내놓도록 학습된다. 즉, 매운 작은 값들을 선택해 잘 분류 하기 위한 충분한 정보들을 가지기 때문에, 이 layer들은 이미지의 의미있는 압축된 요약본이라 할 수 있다. 마지막 레이어를 재학습시키는 것이 잘 작동하는 이유는 1000개의 클래스가 있는 ImageNet을 학습시킨 것이 다른 새로운 종류의 개체를 구별하는데도 유용하기 때문이다.

모든 이미지들은 각각의 Bottleneck을 학습하고 계산하는데 많은 양의 시간을 소모하기 떄문에, 이 속도는 이러한 bottleneck값을 cache화 시켜서 다시 계산될 필요가 없도록 하는 것에 달려있다. /tmp/bottleneck 에 저장된 default값에 의해 만약 다시 프로그램을 돌린다면, 그들은 저장된 값을 사용함으로써 Bottleneck Part를 기다릴 필요가 없다.

Training

일단 Bottleneck이 완료되면, 네트워크 상단 layer의 실제 학습은 진행된다. 여러 스탭의 결과들을 볼 수 있는데, 각각 ‘training accuracy’, ‘validation accuracy’, ‘cross entropy’를 출력한다. 각각의 값을 살펴보면.

Training accuracy : 현재 trainning batch 중 제대로 예측한 data의 비율이다.
validation accuracy : 각각 다른 set으로 부터 무작위로 선택된 이미지의 그룹들의 정확도이다.
- training accuracy를 핵심 지표로 활용할 경우 noise까지도 학습하게 되서 Overfit될 가능성이 있다. 따라서 실제 성능의 척도는 training data에 포함되지 않은 data들에 대한 성능을 확인해야 한다(= validation accuracy).
- Traindata에 대한 accuracy는 높은 반면, Validation accuracy는 낮게 나온다면, Overfitting 됬다는 뜻이며, 이는 좋지 않는 결과이다.
Cross Entropy : loss function으로 학습의 진척도를 보여준다.
우리 학습의 목표는 cross entropy를 가능한 가장 작게 만드는 것이다. 여기에서 우리는 4,000Step(Default)을 학습한다. 각각의 스텝에서 trainning set에서 10개의 무작위 image가 선택한 후 Cache로 부터 각각의 bottleneck을 찾은 후 예측을 위해 마지막 레이어에 통과시킨다. 이러한 예측과 실제 label을 비교해 마지막 레이어의 weight들을 back-propagation 과정을 통해 update시킨다. process가 진행될 수록 우리는 accuracy가 올라가는 것을 확인할 수 있다. 모든 학습이 끝난 후 test를 위해 따로 구분해놓은 set을 예측함으로써 final test accuracy가 나온다. 이 수치는 모델이 얼마나 잘 학습했는지를 알려주는 가장 좋은 지표이다. 우리는 90~95%정도의 수치를 보는데 각각 다른이유는 각각 스탭마다 무작위로 사진을 뽑기 떄문이다.

Visualizing the retraining with TensorBoard

retrain.py 파일은 tensorboard를 포함한다. tensorboard란 weights, accuracy등의 통계수치, 그래프들을 시각적으로 보여줘서 이해, debug, 최적화에 용이하게 한다.

tensorboard를 실행하기 위해 아래의 명령어를 입력하자

tensorboard --logdir /tmp/retrain_logs

Tensorboard가 실행되면,web browser에서 localhost:6006에 접속하면 된다.

retrain.py은 기본적으로 log를 /tmp/retrain_logs에 저장한다. 저장경로는 --summaries_dir flag로 바꿀 수 있다. TensorBoard’s Github Repository에서 TensorBoard에 대한 더욱 많은 설명과 tip들을 확인할 수 있다.

Using Retrained Model

Tensorflow Tutorial - MNIST

2018-05-26T04:45:35+00:00

MNIST

TensorFlow Layers 가이드 : Convoltional Neural Network 만들기

(이 문서는 Tensorflow의 공식 tutorial 가이드를 따라한 것입니다. (Tensorflow tutorial))

MNIST
- TensorFlow Layers 가이드 : Convoltional Neural Network 만들기

[toc]

TF는 쉽게 Neural network을 블록쌓듯 만들 수 있게 high-level의 API로써 Tensorflow LayerModule을 제공한다.(Module 참고)
이번 Tutorial에서는 손글씨 MNIST데이터를 학습하기 위한 CNN모델을 만들기 위해 Layer를 만들 것이다.
MNIST 데이터는 위와 같은 28x28-pixel의 0~9까지의 숫자 데이터로 이루어져있으며, trainning data 는 6만개, test data는 만개로 이루어져 있다.

시작하기

아래와 같은 code로 이루어진 cnn_mnist.py파일을 만든다.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

# Imports
import numpy as np
import tensorflow as tf

## Tensorflow는 5가지 ligging type을 제공한다.( DEBUG, INFO, WARN, ERROR, FATAL )
## default값은 WARN
## 우리는 이를 INFO로 바꿔준다.
tf.logging.set_verbosity(tf.logging.INFO)

# Logic들은 이곳에 추가된다.

if __name__ == "__main__":
  tf.app.run()

최종 코드는 다음에서 확인 가능하다. (Final Code)

CNN 소개

CNN은 연속된 필터를 raw pixel 이미지 데이터에 적용한다. 이를 통해 high-level의 특징을 뽑아내고 학습한다. CNN은 세가지 구성요소로 이루어진다.

Convolution Layers 는 특정한 수의 필터를 이미지에 적용시킨다. 각각의 subregion에 합성곱(Convolution)됨으로써 single value를 만든다. 그 이후 일반적으로 ReLU 활성화 함수를 통과시켜 비선형(non-linear)한 output을 만든다.
Pooling Layers 는 Image data를 downsampling하는 과정이다. Feature map의 차원을 감소시킴으로써 수행시간을 감소시킨다. 일반적으로 Max-pooling을 사용한다.(최고값만을 남기고 나머지는 버린다.)
Dense (fully connected) layers 는 분류를 수행하는 Layer이다. 여기서는 모든 layer들이 이전 모든 노드들과 연결되어있다. 일반적으로 CNN은 위의 요소들을 블록처럼 쌓으면서 만들어지는 model이다.

CNN MNIST 분류기 만들기

다음과 같은 arichitecture를 가지는 모델을 만들어 MNIST 데이터를 분류할 것이다.

Convolutional Layer #1 :32개의 5x5 filter로 구성, ReLU 함수 사용
Pooling Layer #1 : 2x2 Filter로 2stride를 적용해 max pooling사용
Convolutional Layer #2: 64개의 5x5 filter로 구성, ReLU 함수 사용
Pooling Layer #2: 2와 같은 구조
Dense Layer #1: 1,024개의 뉴련, 0.4의 dropout 사용

Tf.layer 모듈은 아래의 3가지 type의 layer를 만들 수 있다.

conv2d(). Constructs a two-dimensional convolutional layer. Takes number of filters, filter kernel size, padding, and activation function as arguments.

max_pooling2d() . Constructs a two-dimensional pooling layer using the * max-pooling algorithm. Takes pooling filter size and stride as arguments.

dense(). Constructs a dense layer. Takes number of neurons and activation function as arguments.

이전의 cnn_mnist.py를 열어 다음과 같이 cnn_model_fn 함수를 만든다.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer 28x28 input size
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer #1 (32개의 5x5 필터, padding = "same"은 입력과 출력 크기가 같도록 유지시킨다. 활성화함수는 ReLU)
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer #1 (2x2, stride2로 Max-pooling사용)
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer #2(64개의 5x5필터)
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=64,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer (3136x1로 reshape 한뒤 1024x1로 만든후 dropout실행 )
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
  dense = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      # Add `softmax_tensor` to the graph. It is used for PREDICT and by the
      # `logging_hook`.
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss (for both TRAIN and EVAL modes)
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics (for EVAL mode)
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

이제부터 함수 하나씩 살펴보자

tf.layer.conv2d
```
conv1 = tf.layers.conv2d(
 inputs=input_layer,
 filters=32,
 kernel_size=[5, 5],
 padding="same",
 activation=tf.nn.relu)
```
- Convolutional Layer #1 & Convolutional Layer #2
- 모든예시는 첫번째 conv인 Convolutional Layer #1을 예로 한다.
- input은 다음과 같은 shape을 가져야 한다.
  - [batch_size, image_height, image_width, channels]
  - 여기서는 [batch_size, 28, 28, 1]이 된다.
- filter는 필터의 수를 뜻한다.
- kernel_size 는 filter의 크기를 뜻한다.
  - [height, width] (여기서는, [5, 5]).
- padding 은 valid 값(default) 혹은 same 값으로 설정한다.
  - valid 는 패딩 없음
  - same 은 0패딩을 포함시켜, 출력 크기가 입력 크기 와 동일 하게 한다.
- activation 은 활성화 함수를 선택한다. 여기서는 ReLU함수를 사용하므로 tf.nn.relu 로 하였다.
- 따라서 conv2d의 아웃풋인 conv1의 shape은 [batch_size, 28, 28, 32] 을 가진다.
tf.layer.max_pooling2d
- Pooling Layer #1 & Pooling Layer #2
- 모든 예시는 첫번째 pool인 Pooling Layer #1으로 한다.
- Pooling 필터를 2x2 로 하고 stride를 2로하여서 겹치는 부분없이 최대값을 뽑아내는 max pooling을 사용하였다.
- 풀링을 함으로써 height과 width의 size가 절반으로 줄었다.( [batch_size, 14, 14, 32] )
Dense Layer
- Fully Connected Layer를 만들기 위한 과정이다.
- 먼저 우리는 feature map(pool2)을 tf.reshape 함수로 평평하게 만들어 준다.
```
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
```
- reshpae()함수에서 -1은 batch_size에 맞게 설정되도록 한다. 따라서 reshape을 하고 나면 shape가 [batch_size, 3136] 가 된다.
```
dropout = tf.layers.dropout(
 inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
```
- 평평하게 만든 뒤 tf.layers.dense 함수를 사용해 dense layer와 연결한다.
  - input값은 평평하게 만든 feature map 값(pool2_flat)이다
  - units 값은 dense layer의 뉴런의 수이다. (1024)
  - 활성화 함수는 ReLU 사용
- dense layer와 연결한 뒤 Dropout 사용 (0.4)
  - tf.layers.dropout함수 에서 training 인자는 현재 학습 상태인지 예측하는 상태인지를 Bool 값으로 받는다. 학습상태에서만 dropout 실행
- Output 값은 [batch_size, 1024]
Logits Layer
- 마지막으로 1024개의 뉴런을 10개의 뉴런(0~9 예측 위해) 으로 만드는 Logit layer 만든다.
```
logits = tf.layers.dense(inputs=dropout, units=10)
```
- Linear activation 사용(default)
- 최종 output은 [batch_size, 10]
Generate Predictions
- “Class” 와 “probabilities”값 리턴
  - Class 는 argmax값 통해 가장 값이 큰 것의 index 리턴
  - Probabilities는 softmax값 리턴(tf.nn.softmax 함수 사용)
- mode 가 예측일 때만 리턴

predictions = {
    "classes": tf.argmax(input=logits, axis=1),
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
}
if mode == tf.estimator.ModeKeys.PREDICT:
  return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

Calculate Loss
- MNIST 분류 문제는 multi-classication 문제이므로 일반적으로 cross entropy 사용
- 아래의 코드는 trainning과 evaluation 모두에서 사용된다.
```
onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10)
loss = tf.losses.softmax_cross_entropy(
 onehot_labels=onehot_labels, logits=logits)
```
- label one-hot 인코딩 방식이므로 tf.one_hot 함수 사용
  - one-hot 함수의 indices 인자는 1로 표시할 index
  - depth는 벡터의 크기로 class수가 된다.
Configure trainning Op
- 학습하는 동안 Loss를 갱신시킬 방법을 선택한다.
- 이번 예제에서는 SGD(Stochastic Gradient Descent)를 사용한다.(learning_rate = 0.001)

if mode == tf.estimator.ModeKeys.TRAIN:
  optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
  train_op = optimizer.minimize(
      loss=loss,
      global_step=tf.train.get_global_step())
  return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

Add Evaluation Matrics

accuracy를 추가한 Estimator를 만든다.

eval_metric_ops = {
 "accuracy": tf.metrics.accuracy(
   labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(
 mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

실제로 MNIST 분류기를 학습시키고 평가하기

Trainning data와 Test data를 불러온다.

main()함수를 만들어서 data를 불러온다.

def main(unused_argv):
# Load training and eval data
mnist = tf.contrib.learn.datasets.load_dataset("mnist")
train_data = mnist.train.images # Returns np.array
train_labels = np.asarray(mnist.train.labels, dtype=np.int32)
eval_data = mnist.test.images # Returns np.array
eval_labels = np.asarray(mnist.test.labels, dtype=np.int32)

data들은 numpy배열로 이루어져 있다.

Create Estimator
- main()함수에 estimator를 추가한다.
```
mnist_classifier = tf.estimator.Estimator(
 model_fn=cnn_model_fn, model_dir="/tmp/mnist_convnet_model")
```
- model_fn 인자로는 우리가 위에서 만들었던 함수를 넣는다.
- model_dir은 model이 저장될 위치를 지정한다.
Set up Logging Hook

logging할 방법을 정한다.

tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(
    tensors=tensors_to_log, every_n_iter=50)

여기서 tf.train.SessionRunHook을 사용해 tf.train.LoggingTensorHook만들 수 있다. 이를 통해 softmax값인 확률값을 logging할 수 있다.

모델 학습하기

main()함수에 다음의 train함수를 추가한다.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
  x={"x": train_data},
  y=train_labels,
  batch_size=100,
  num_epochs=None,
  shuffle=True)
mnist_classifier.train(
  input_fn=train_input_fn,
  steps=20000,
  hooks=[logging_hook])

모델 평가하기

다음의 함수를 main()에 추가해서 Estimator를 추가한다.

eval_input_fn = tf.estimator.inputs.numpy_input_fn(
  x={"x": eval_data},
  y=eval_labels,
  num_epochs=1,
  shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

이제 완성된 cnn_mnist.py파일을 실행시킨다.

Run cnn_mnist.py.

정확도 : 97.3%

Tensorflow 설치하기

2018-05-26T04:45:35+00:00

Tensroflow 설치하기

이때까지 공부할때는 tensorflow를 사용하지 않고 아나콘다 배포판의 라이브러리들로만 했었는데, 미리미리 tensorflow를 손에 익혀 두는 것이 좋을 것같아 tensorflow tutorial를 따라가며 손에 익혀 보기러 한다.

Tensroflow 설치하기

1. Tensorflow

tensorflow의 설치방법에는 여러가지가 있지만(참고:Tensorflow Site), 여러 방법 중 나는 Ananconda를 통해 다운 받는 방법을 선택했다.

설치하기 전에 tensorflow는 CPU-only 와 GPU도 사용하는 방법 두가지로 나눠져있다. Tensorflow site의 설명을 확인하면,

TensorFlow with CPU support only. If your system does not have a NVIDIA® GPU, you must install this version. Note that this version of TensorFlow is typically much easier to install (typically, in 5 or 10 minutes), so even if you have an NVIDIA GPU, we recommend installing this version first. Prebuilt binaries will use AVX instructions.

TensorFlow with GPU support. TensorFlow programs typically run significantly faster on a GPU than on a CPU. Therefore, if your system has a NVIDIA® GPU meeting the prerequisites shown below and you need to run performance-critical applications, you should ultimately install this version.

그리고 GPU-version을 사용하기 위해서는 요구사항들이 있다.

CUDA® Toolkit 9.0
The NVIDIA drivers associated with CUDA Toolkit 9.0
cuDNN v7.0
GPU card with CUDA Compute Capability 3.0 or higher for building from source and 3.5 or higher for our binaries

요구사항에 대한 자세한 내용들을 사이트를 참고하자(Tensorflow, NVIDIA)

현재 나는 따로 GPU가 없기 떄문에 일반 버전으로 설치하기로 했다.

2. 설치하기

우선 관리자 권한으로 Anaconda Prompt를 실행시켜 준다. (Anaconda를 설치하지 않은 사람은 Anaconda를 먼저 설치한다.(아나콘다 설치))
이후 pip 버전을 최신버전으로 맞춰준다.
```
C:> python -m pip install --upgrade pip
```

tensorflow이름으로 conda환경만들기

C:> conda create -n tensorflow pip python=3.5

conda 환경 활성화
```
C:> activate tensorflow
```
활성화를 하게 되면 prompt가 (tensorflow) 로 바뀌게 된다.
```
(tensorflow)C:>
```
CPU-only 또는 GPU 두 가지 버전 중 하나를 골라서 설치한다.

CPU-only

(tensorflow)C:> pip install --ignore-installed --upgrade tensorflow

GPU version

(tensorflow)C:> pip install --ignore-installed --upgrade tensorflow-gpu

여기까지 별 다른 error가 뜨지 않았다면 잘 설치 된 것이다. 그러면 이제 제대로 설치가 되었는지 확인 해 보자.

3. 설치 확인하기

Anaconda를 통해 설치했기 떄문에 anaconda prompt를 통해 실행 해본다

Anaconda 실행 후 Python 실행
```
(tensorflow)C:> python
```

tensorflow import 후 사용

>>> import tensorflow as tf
>>> hello = tf.constant('Hello, TensorFlow!')
>>> sess = tf.Session()
>>> print(sess.run(hello))

만약 잘 설치되었다면, 다음과 같은 문장이 출력 될 것이다.
```
Hello, TensorFlow!
```

다음 부터는 이제 TensorFlow의 공식 Tutorial(TensorFlow Tutorial) 문서를 보며 하나씩 따라 해보도록 하겠다.

Recent trend in NLP

2018-05-09T00:00:00+00:00

Recent Trends in Deep Learning Based Natural Laguage Process (2017)
- 최신의 딥러닝 기반 자연어처리기법 최근 연구 동향

0. 서론
1. Distributed representation(분산표상)
- B. Word2Vec
- C. Character Embeddings(문자 임베딩)
2. CNN
- A. CNN 기본구조
  - 1) 문장 모델링
  - 2) window approach
- B. CNN Application

0. 서론

기존의 NLP풀기위한 머신러닝 기법들은 sparse한 feature를 shallow한 model(ex>SVM)이였다.
최근에는 워드 임베딩과 딥러닝 모델 기법의 성공에 힘입어 dense한 vector representation에 기반한 NN가 trend이다.
- Recurrent neural network based language model
  - http://www.fit.vutbr.cz/research/groups/speech/publi/2010/mikolov_interspeech2010_IS100722.pdf
  - Sequential data모델 위해 Recurrent Neural Network 사용(Simple RNN or Elman network 아키텍쳐 사용)
- Distributed Representations of Words and Phrases and their Compositionality
  - https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf
  - Word2Vec
  - 2가지 모델 CBOW(Continuous bag of words)와 Skip-gram 제시
  - CBOW
    - CBOW 모델도 마찬가지의 방법을 사용한다. 주어진 단어에 대해 앞 뒤로 C/2개 씩 총 C개의 단어를 Input으로 사용하여, 주어진 단어를 맞추기 위한 네트워크를 만든다.
    - CBOW 모델은 크게 Input Layer, Projection Layer, Output Layer로 이루어져 있다. 그림에는 중간 레이어가 Hidden Layer라고 표시되어 있기는 하지만, Input에서 중간 레이어로 가는 과정이 weight를 곱해주는 것이라기 보다는 단순히 Projection하는 과정에 가까우므로 Projection Layer라는 이름이 더 적절할 것 같다.
    - Input에서는 NNLM 모델과 똑같이 단어를 one-hot encoding으로 넣어주고, 여러 개의 단어를 각각 projection 시킨 후 그 벡터들의 평균을 구해서 Projection Layer에 보낸다.
    - 뒤는 여기에 Weight Matrix를 곱해서 Output Layer로 보내고 softmax 계산을 한 후, 이 결과를 진짜 단어의 one-hot encoding과 비교하여 에러를 계산한다.
  - Skip-Gram
    - CBOW와는 반대 방향의 모델이라고 생각할 수 있을 것 같다.
- Recursive Deep Models for Semantic Compositionality Over a Sentiment Treebank
  - https://nlp.stanford.edu/~socherr/EMNLP2013_RNTN.pdf
Collobert el al(2011, http://www.jmlr.org/papers/volume12/collobert11a/collobert11a.pdf)은 간단한 딥러닝 프레임워크들에 대해 제시하였다.
- Named Entity Recognition, NER(개체명 인식)
- Semantic Role Labelling, SRL(의미역결정)
- POS tagging(품사태깅)
이후 많은 복잡한 딥러닝 기반의 프레임워크들이 제시되었다.
- CNN
- RNN
- Recursive NN
위의 주요적인 프레임워크들 뿐만 아니라 최근의 여러 모델 또한 제시 되었다.
- Attention 메커니즘
- RL
- Deep Generative Model
이 논문 이전 NLP연구의 딥런닝 기법들의 소개는 Goldberg(2016)을 제외하고 전무했다.
- Goldberg 또한 다양한 딥러닝 아키텍쳐에 대해 논의한것은 아니고 튜토리얼 방식으로 NLP를 소개하고 Word2Vec과 CNN같은 distributional semantics에 주로 초점을 맞춘다.
- http://u.cs.biu.ac.il/~yogo/nnlp.pdf
이후 이 논문의 구성은 섹션2에서 Distributed representation(분산표상)에 대해서 소개하고 섹션 3,4,5에서는 CNN,RNN,Recursive NN을 소개한 후 섹션 6에서 NLP에서 사용된 강화학습 응용사례와 비지도학습기법의 발전에 대해서 알아볼 것이며, 섹션 7에서는 딥러닝 모델과 메모리 모듈 결합의 최근 트렌드를 소개한다.

1. Distributed representation(분산표상)

Distributed representation연구의 동기
- 통계기반의 자연어 처리 기법은 복잡한 자연어를 모델링하는데 이 기법은 초기에 ‘차원의 저주(curse of dimentionality)’에 어려움을 겪는다
- Language model은 결합함수를 학습해야 하기 때문이다.
- 따라서 저차원 벡터공간에 존재하는 단어의 분산표상을 연구의 동기가 되었다.
A. Word Embedding(단어 임베딩)
Distributed vectors와 Word Embedding은 근본적으로 distributional hypothesis를 전제로 한다.
Distributional hypothesis라는 이 가정은 비슷한 의미를 지닌 단어는 비슷한 문맥에 등장하는 경향이 있을 것이라는 내용이 핵심이다.
따라서 이 벡터들은 이웃한 단어의 특징을 잡아내고자 한다. 따라서 벡터들은 단어간 유사성을 내포한다.
유사도는 Cosine 유사도같은 지표를 사용한다.
(Figure 1. D차원 벡터로 표현된 단어 벡터. V를 전체 단어 수라고 할 때, D는 V보다 훨씬 작다.)
Word Embedding은 Deep learning model의 첫 번째 데이터 처리 계층에서 주로 사용된다.
Word Embedding은 단어들의 의미와 구문론적인 의미들을 학습하기위해 보조적인 목적으로 최적화하는 형태로 사전 학습된다. (Mikolov et al., 2013b, a).
또한 Embedding Vector의 Dimension이 작은 덕분에 계산이 빠르고 효율적이다.
이러한 방법은 전통적인 방법인 Word count 기반의 모델과 딥러닝 기반의 모델과의 가장 큰 차이점이다.
Word Embedding은 NLP문제의 광범위한 범위에서 state-of-art한 결과를 이끌어 냈다(Weston et al.2011, ; Socher et al., 2011a; Turney and Pantel, 2010).
Glorot et al.(2011)는 도메인 특성에 맞는 감성 분류를 위한 stacked denoising autoencoder 모델에 word embedding을 사용했다.
Hermann and Blunsom(2013)는 embedding을 활용해 문장 합성을 학습하기 위한 combinatory categorical autoencoders를 제안했다.
Embedding은 주로 Context를 통해 학습된다.
초기의 embedding에 대한 연구
- 1990년대의 Dumais, 2004; Elman, 1991; Glenberg and Robertson, 2000
- Latent Dirichlet Allocation, Blei et al., 2003, 블로그와 같은 토픽 모델과 언어모델(Language models, Bengio et al., 2003)
- 표현학습(representation learning, 블로그)
- 분산표상을 학습하는 신경 언어 모델(Bengio et al.(2003))
- 사전 학습된 단어 임베딩의 유용성(Collbert and Weston(2008))
위의 많은 word embedding에 대한 연구가 있었지만, 가장 많은 인기를 끌고 있는 임베딩 기법은 Milokov et al.(2013a)의 CBOW와 skip-gram모델이다.
Pennington et al.(2014)은 word2vec과 달리 빈도수 기반의 단어 임베딩 기법이다(참고: 블로그)
- 위의 기법은 우선 word co-occurence count matrix를 생성한 뒤 빈도 수를 정규화 하고 log smooting을 한다.
- 저차원 벡터를 얻기 위해 Reconstruction loss를 최소화하는 방식으로 이 행렬을 factorize한다.

B. Word2Vec

Mikolov et al이 제시한 모델, 첫 논문(Efficient Estimation of Word Representations in Vector Space)과 여러 튜닝 기법이 포함 된 두번 째 논문으로 구성(Distributed Representations of Words and Phrased and their Compositionality)
CBOW와 Skip-gram으로 구성
CBOW
- k개만큼 주변 단어가 주어 졌을 때 중심 단어의 조건부 확률을 계산한다.
- (Figure 2. Word2Vec의 CBOW 모델) -> 1개의 hidden layer 가진 simple fully connected neural network이다.
Skip-Gram
- CBOW와 정반대로 중심단어가 주어졌을 때 주변 단어를 예측한다.
개별 단어 임베딩의 한계는 두개 이상의 단어의 조합(ex. hot potato -> hot + potato의 의미와 전혀 다른 의미)이 ㄱ개별 단어 벡터의 조합으로 표현될 수 없다.
- 위의 문제의 해결책은 동시등장단어(word coocurrence)에 기반한 구문 식별, 이들 별도로 학습
- 최근의 기법은 레이블이 없는 데이터로 부터 n-gram 임베딩을 직접적으로 학습시키는 방법(Johnson and Zhang, 2015).
또다른 한계는 주변 단어의 작은 window 내에만 기반한 임베딩을 학습하는데서 비롯된다. -> Good과 Bad가 같은 임베딩을 공유할 수 있다. -> 감정분석에서 문제될 수 있다.
- 이러한 임베딩은 위와 같이 상반된 극성 갖는 단어가 의미상 유사한 단어로 Clustrering된다.
- 이러한 문제 해결을 위해 Tang et al. (2014)는 Sentiment specific word embedding(SSWE)을 제안 -> 임베딩을 학습하는 동안 손실함수에 감정에 대한 양,음 값을 포함시켰다.
단어 임베딩의 주의사항은 임베딩이 사용된 application(space)에 의존한다.
따라서 Labutov and Lipson (2013)은 단어 벡터를 재학습해서 현재 task space에 맞추기 위해 task specific embedding을 제안했다.
Mikolov et al. (2013b)는 negatice sampling 기법 제안

C. Character Embeddings(문자 임베딩)

단어 임베딩은 문법적, 의미적 정보를 잡아낼 수 있다. 그러나 품사태깅(POS-tagging)이나 개체명인식(NER) 같은 task 에서는 단어 내부의 형태,정보(문자) 또한 중요하다.
문자 수준의 NLP시스템 구축도 관심을 끌고 있다. (Kim et al. ,2016 ; Dos Santos and Gatti, 2014; ‘Santos and Guimaraes, 2015](http://www.anthology.aclweb.org/W/W15/W15-3904.pdf); Santos and Zadrozny, 2014).
- Santos and Guimaraes (2015)는 단어 임베딩과 함께 문자 수준 임베딩을 개체명 인식 문제에 적용해 스페인어에서 state-of-art한 성과 이뤘다.
- Kim et al. (2016)은 문자 임베딩만 사용한 enural laguage model을 구축해 긍적적인 결과를 보였다.
- Ma et al. (2016)은 개체명인식에서 pre-trained된 레이블 임베딩을 학습위해 문자 trigram을 포함 몇몇 임베딩 기법 활용했다.
문자 임베딩은 미등재단어(the unknown word) 이슈 대처 가능하다.
중국어와 같은 단어의 의미가 문자들의 합성에 대응되는 언어에서는 문자수준의 시스템 구축은 단어분할(word segmentation)을 피하기 위해 자연스러운 선택이다.
Peng et al. (2017)은 radical 기반의 처리가 감성 분류 성능 개선시킴을 입증했다.

2. CNN

문장모델링에서 CNN을 활용하는 것은 Colobert and Weston(2008)에서 시작되었다.
- 이 연구는 다범주 예측결과를 출력 위해 multi-task learning을 사용했다.
- 품사태깅, 청킹, 개체명인식, 의미역결정, 의미적으로 유사한 단어 찾기, 랭귀지 모델 같은 NLP 과제 수행 위해 사용
- Look up table(참조테이블)은 각 단어를 사용자가 정의한 차원 벡터로 변형해 사용
- 따라서 Input {s1,s2,..,sn}은 참조테이블 활용해 벡터들의 나열로 변형 {ws1,ws2,…,wsn}
- (Figure 3. Colbert and Weston(2008)이 제시한 CNN 프레임 워크. 그들은 단어 범주 예측에 이 모델 사용
Collobert et al. (2011)은 NLP문제들을 해결 위해 일반적인 CNN기반 프레임워크를 제안했다.
위의 논문들은 NLP 연구자들 사이에 CNN이 큰 인기를 끌도록 촉발 시켰다.
CNN은 문장의 잠재적인 semantic represention을 만들기 위해 입력 문장으로부터 핵심적인 n-gram feature를 추출하는 능력 가진다.
- 이 분야의 업적은 Collobert et al. (2011), Kalchbrenner et al. (2014), Kim(2014)이다(블로그.

A. CNN 기본구조

1) 문장 모델링

문장의 $i$번째 단어에 해당하는 임베딩 벡터를 $w_i\in R^d$, 임베딩 벡터의 차원수를 $d$라 두면, $n$개 단어로 이루어진 문장 주어졌을 떄, 문장은 $n$ x $d$(W$\in$$R^{n*d}$) 크기의 Embedding matrix로 표현할 수 있다.
텍스트 처리를 위한 CNN Zhang and Wallace(2015)
$w_i, w_{i+1}, …, w_j$ 의 결합(concatenation)(=$d$x$(j-i)$ dimension의 matrix가 된다)을 $w_{i:i+j}$ 라 두자.
콘볼루션은 위의 값(Input embedding layer)에 의해 수행 된다.
Convolution Filter $k$는 dimension이 $hd$인 filter이다. 이 Filter는 h개의 단어에 window로 작용해 새로운 feature를 만든다.
예를 들어 feature $c_i$는 $w_{i:i+j}$에 window를 씌움으로써 만들어 진다.

$c_i = f(w_{i:i+h-1}\cdot k^T+b)$

여기서 b는 bias이고 f 는 activation ftn이다.
Filter k 는 모든 window에 같은 weight로 적용되서 feature map 을 만든다. $c = [c_1, c_2, ..., c_{n+h-1}]$
CNN에서 각각 다른 width의 많은filter(called kernel) 전체 word embedding matrix에 slide 된다.
각각의 kernel은 n-gram의 각각의 특징을 추출한다.
convolution layer는 주로 max-pooling을 사용함
- 최대값을 취함으로써 subsampling을 한다.
- max-pooling을 사용하는데는 두가지 이유가 있다,
  - 첫번째, max-pooling은 classification에 필요한 fixed-length output을 제공한다. 따라서 filter의 size에 상관없이 고정된 크기의 output을 제공한다.
  - 두번째, max-pooling은 전체 문장에서 중요한 n-gram feature들을 보존한채 output의 dimension을 감소시킨다. 이러한 방법은 개별 filter에서 특정한 feature(ex.부정)을 잘 추출할 수 있다.
Convolution layer와 max-pooling을 겹겹이 쌓는 sequential convolution은 풍부한 정보를 포함한 고도로 추상화된 표현을 잡아내 문장분석을 개선 할 수 있다.

2) window approach

위의 CNN 아키텍쳐는 자연어 문장을 벡터로 표현한다.
그러나 개체명 인식, 품사태킹, SRL과 같은 task에서는 단어 단위의 예측이 필요하다.
따라서 이러한 task들에 적용하기 위해 window 접근법이 사용된다.
window approach는 단어의 범주(tag)가 이웃한 단어에 의존할 것이라 가정한다.
따라서 각 단어에 대해 고정된 크기의 window가 적용되고 그 윈도의 내의 하위 문장들(sub-sentence)이 고려된다.
Standalone CNN은 이러한 하위 문장들(sub-sentence)에 적용되고 윈도우 중앙의 단어에 의해 예측된다.
이러한 접근에 따라 Poria et al. (2016a)는 문장 각 단어에 aspect(주제) 혹은 non-aspect태그를 붙이기 위해 multi-level Deep CNN을 제안했다.
- 언어적 패턴 집합과 함께 사용한 앙상블 classifier는 aspect detection에 있어 좋은 성능을 냈다.
단어 수준 분류의 주요 목표는 전체 문장에 레이블 시퀀스(sequence)를 할당하는 것이다.
Conditional Random Field(CRF) 같은 구조화된 예측 기법(structed prediction)은 때때로 인접한 클래스 레이블 간의 의존성을 더 잘 포착한다.
이 기법은 결국 전체 문장에 최대 스코어를 내는 결합된 레이블 시퀀스(cohesive label sequence)를 생성한다(Kirillov et al., 2015).
더 넓은 문맥적 범위를 위해 전통적인 윈도우 접근법은 종종 time-dealy neural network(TDNN)와 결합된다.(Waibel et al., 1989).
위의 방법에서 Convolution은 모든 window에서 적용된다.
하지만 filter들의 폭이 고정되었기 때문데 convolution은 제약을 가진다. 이러한 문제를 해결하기 위해 전통적인 방법은 레이블이 달린 단어 주변의 윈도우에 있는 단어들만 고려하지만, TDNN은 윈도의 내의 모든단어를 고려한다.
때떄로 TDNN는 CNN처럼 stack처럼 쌓여 하위 계층에서는 local feature 상위계층에서는 global feature를 뽑아낸다.

B. CNN Application

CNN을 사용한 다양한 응용들을 소개한다.
Kim(2014.)은 감성, 주관(Subjectivity), 질문유형 분류 포함해서 다양한 sentence 분류 문제에 CNN Architecture를 사용했다.
- Kim의 연구는 간단하지만 효율적이라 많이 사용되었다.블로그참고
- 특정 task에 대한 trainning후, random initialized convolution kernel은 특정 목적에 융요한 n-gram feature 탐지기가 되었다.
- 그러나, Long-term의 dependency를 모델링 할 수 없다는 등 여러 단점이 있다.
- (Figure4. Top 7-gram by four learned 7-gram kernel ; 각각의 필터는 특정 종류의 7-gram에 민감하다.)
이러한 이슈(long-term dependency)를 해결하기 위해, Kalchbrenner et al.(2014)은 DCNN(Dynamic CNN)을 제안했다.
- DCNN은 dynamic k-max pooling을 사용한다.
  - dynamic k-max pooling이란 시퀀스$p$가 주어졌을 때 가장 active한 k개의 feature를 뽑는 것이다.
  - 이러한 선택들은 순서를 보존하지만 위치에는 민감하지 않다.
  - (Figure5.DCNN의 sub-graph.)
  - DCNN = TDNN(base) + dynamic k-max pooling
  - 이러한 전략은 filter의 좁은 너비가 넓은 범위의 sentence를 cover할 수 있게 되었다.
  - Figure5 에서 상위의 Feature는 가변적인 너비를 가진다.
  - 즉 이 연구는 문맥적 의미를 모델링하는 데 있어 개별 필터의 범위(range)에 대해 언급했고, 필터의 도달 범위를 확장하는 방법론을 제안했다.
감정분석에 필요한 task는 효과적인 aspect추출과 감정 극성(polarity)이다.(Mukerjee and Liu, 2012)
- Ruder et al. (2016)은 좋은 결과를 위해 word embedding 과 aspect vector를 결합한 값을 input으로 하는 CNN적용했다.
CNN은 Text의 길이에 따라 성능이 달라진다.
- 장문에서는 CNN 성과가 좋았으나, 단문에서는 성과가 좋지 않았다.
Wang et al.(2015b)은 짧은 Text 표현에 CNN을 사용하기 위해 외부의 지식이 사용된 multi-scale semantic units를 도입한 의미적 clustering(semantic clustering)을 제안했다.
- CNN은 이러한 Unit들을 결합해 represention을 만들어 낸다.
CNN에서 고도의 문맥정보를 요구하는 것은 어렵다.
- CNN사용한 단문 분석을 종종 부가정인 정보와 외부 지식을 필요로 한다.
- Poria et al.(2016)은 CNN을 활용하여 twitter text에서 빈정대는 부분을 찾아내는 task(sarcasm detection)를 만들었다.
- 여기에서 감정,감성,개별 데이터셋이 사전학습된 보조적인 자료로서 사용되어서 state-of-the-art한 성능을 이끌어 냈다.

reniew's blog

ALBERT: A Lite BERT For Self-Supervised Learning of Language Representations

Introduction

The Elements of ALBERT

Model Architecture choices

Model setup

Experiments

Overall Comparison between BERT and ALBERT

Factorized Embedding Parameterization

Cross-Layer Parameter Sharing

Sentence Order Prediction(SOP)

A Structured Self-Attentive Sentence Embedding

1 Introduction

2 Approach

2.1 Model

2.2 Penalization Term

2.3 Visualization term

Conclusion & Discussion

BERT: Bidirectional Transformers for Language Understanding

1 Introduction

2 Related Work

2.1 Feature-based Approaches

2.2 Fine-tuning Approaches

2.3 Transfer Learning from Supervised Data

3 BERT

3.1 Model Architecture

3.2 Input Representation

3.3 Pre-training Tasks

3.4 Pre-training Procedure

3.5 Fine-tuning Procedure

4 Conclusion

End to End Memory Network

Introduction

Approach

Single Layer

Multiple Layers

Result & Conclusion

Memory Network

Introduction

Memory Network

A MenNN Implementation for Text

Basic model

Word Sequences as Input

Result & Conclusion

ConvS2S: Convolutional Sequence to Sequence Learning

Introduction

Recurrent Sequence to Sequence Learning

A Convolutional Architecture

Experiment

Result

Conclusion

Transformer: Attention is all you need

Introduction

Model Architecture

Encoder & Decoder

Attention

Position-wise Feed-Forward Networks

Embeddings and Softmax

Positional Encoding

Why self-attention

Training

Conclusion

CS20(TensorFlow) Lecture Note (12): Machine Translation, Seqeunce-to-sequence and Attention

Post list

12. Machine Translation, Seqeunce-to-sequence and Attention

Machine Translation

How to evaluate Machine translation

Seqeunce to sequence

Attention

Beam Search

CS20(TensorFlow) Lecture Note (11): RNNs in the TensorFlow

Post list

11. RNNs in the TensorFlow

From feed-forward to Recurrent Neural Networks(RNNs)

Back-propagation through Time(BPTT)

Gated Recurrent unit(LSTM and GRU)

Application

RNN in TensorFlow

Tips and Tricks for implementation

Language Modeling in TensorFLow