Backgrounds

Layer Normalization

Layer Normalization (LayerNorm)은 한 샘플 내부에서 feature 차원 기준으로 정규화하는 기법이다. 배치 크기와 무관하게 동작하도록 설계되었다.

$$\mu = \frac{1}{d}\sum_{i=1}^{d} x_i,\qquad \sigma^2 = \frac{1}{d}\sum_{i=1}^{d}(x_i - \mu)^2$$ $$\hat{x}_i = \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon}}\\ y_i = \gamma_i \hat{x}_i + \beta_i$$

Transformer에서 한 토큰의 representation은 보통 $x \in \mathbb{R}^{d_{\text{model}}}$ 이고, LayerNorm은 각 토큰마다 independently 적용된다. 이는 attention 출력의 scale 폭주를 방지하여 학습 안정성이 증가한다.

Recurrent Neural Network

RNN 은 단일 입력이 아닌 여러개의 입력 (시퀀스) 에서, 이전 상태와 현재 입력으로 새로운 상태를 만드는 순환 연산 블록이다.

길이가 $T$ 인 시퀀스 $x$ 가 있을 때, RNN 의 연산을 아래와 같이 정의된다.

$$x=[x_1, x_2, x_3 \dots x_T]\\ h_t=g(W_xx_t+W_hh_{t-1}+b)\\ \\\quad\\ h_1 = g(W_x x_1 + W_h h_0+b)\\ h_2 = g(W_x x_2 + W_h h_1+b)\\ \vdots\\ h_T = g(W_x x_T + W_h h_{T-1}+b)$$

여기서 같은 시간 스텝 $t$ 에서는 같은 파리미터 ($W_x, W_h, b$) 를 공유한다.

hidden state $h$ 를 굳이 만드는 이유는 $t$ 에서 $0$ ~ $t-1$ 범위의 데이터를 모두 참조하려면 계산 비용과 메모리를 많이 요구하기 때문이며 길이가 가변인 시퀀스를 고정 차원으로 처리하기 위한 구조적 장치로 사용하기 위함이다. 즉 이전의 상태를 하나의 벡터 $h$ 로 표현하는 것이다.

$$P(x_t \mid x_1, \dots, x_{t-1})\approx P(x_t \mid h_{t-1})$$

각 시퀀스에서 계산된 $h_t$ 를 사용하여 출력을 만들 수도 있다. 최종 상태 $h_T$ 는 시퀀스 전체를 표현하는 벡터이며, 이를 이용해 출력을 하나만 만들 수도 있고, 중간 $h_t$ 를 이용하여 출력을 시퀀스로 만들 수도 있다.

이러한 RNN 구조는 입력과 출력 시퀀스의 길이가 동일한 문제에는 자연스럽게 적용되지만, 기계 번역과 같이 입력 시퀀스의 길이 $T_x$와 출력 시퀀스의 길이 $T_y$가 다른 문제에는 직접 적용하기 어렵다. 이를 해결하기 위해 이후 Encoder–Decoder 구조가 제안되었다.

Encoder-Decoder

Encoder-Decoder 는 기계 번역, 요약, 질의 응답 등의 $T_x \neq T_y$ 인 Task에서 단일 RNN 의 구조적 한계를 극복하기 위해 고안된 구조이다.

기본적으로 RNN 을 두개 사용하며, 입력 시퀀스를 하나의 표현 ($h_{T_x}$) 으로 인코딩하는 Encoder 와 그 표현을 조건으로 새로운 시퀀스를 디코딩하는 Decoder 로 나뉜다.

첫번쨰 RNN 이 모든 시퀀스를 전부 연산하였을 때, 해당 시퀀스는 $h_{T_x}$ 로 요약된다.

디코더는 이 $h_{T_x}$ 를 $s_0$ 로 사용하여 다음 출력의 확률을 생성한다.

$e_t$ 는 해당 출력 토큰의 embedding 값을 의미한다:

$$e_t=\text{Embed}(y_t) \quad e_t \in \mathbb{R}^{d_e}\\ \quad\\ s_0=h_{T_x}\\ y_0=\langle\text{SOS}\rangle\\ s_t=g(W_ye_{t-1}+W_ss_{t-1}+b)\\ \quad\\ W_o\in \mathbb{R}^{|V|\times d_s} \quad\\ o_t=W_os_t+b_o\\ \quad\\ P(y_t|y_{<t},x)=\text{softmax}(o_t)$$

즉 디코더는 인코더가 요약한 정보 $s_0$ 를 바탕으로 출력을 생성하는데, 언어 모델에서 출력 $y_t$ 은 어휘 테이블 $V$ 에서의 정수 토큰 인덱스를 의미한다.

$s_t$ 는 또 다른 파라미터 $W_o$ 와 곱해져 logit 을 만드는데, 이 logit 을 softmax 함수에 통과시키면 모든 토큰에 대한 확률 분포를 구할 수 있다. 추론 시에는 이 분포로부터 확률이 가장 높은 토큰을 선택하여 출력 $y_t$를 결정한다.

Encoder–Decoder 구조는 Seq2Seq 문제를 가능하게 한 아키텍처이지만, 입력 시퀀스 $x$를 단일 벡터 $s_0$로 요약함으로써 과도한 정보 압축이 발생하는 한계를 가진다.

$$x=\text{FC Bayern is the best club in the world.} \\ y=\text{You're right. Germany International is the best.}$$

위 예시와 같이 입력 시퀀스 초반에 등장한 핵심 토큰에 대한 정보는 최종 hidden state $h_{T_x}$에 충분히 보존되기 어렵고, 이로 인해 디코더가 입력의 일부 의미를 제대로 반영하지 못한 출력을 생성할 수 있다.

이러한 한계를 해결하기 위해 Attention 메커니즘이 제안되었다.

Attention Mechanisms

Neural Machine Translation by Jointly Learning to Align and Translate

우선 “Neural Machine Translation by Jointly Learning to Align and Translate” 에서의 RNN 은 Bi-directional 구조이다. 양방향 RNN 이라는 뜻으로, 두개의 RNN 이 서로 다른 방향으로 진행한다:

$$\overrightarrow{h}_t=f(\overrightarrow{h}_{t-1}, x_t)\\ \overleftarrow{h}_t=f(\overleftarrow{h}_{t+1}, x_t)$$

즉 왼쪽 → 오른쪽은 과거의 context, 오른쪽 → 왼쪽은 미래의 문맥을 담당한다. 이는 입력 시퀀스를 서로 다른 방향으로 읽어 토큰별로 더 풍부한 표현이 가능하게 한다. 출력을 미리 예측할 수 없는 Encoder-Decoder 의 구조 상, 인코더에만 두개의 RNN 이 각 방향을 담당하며, 두 방향의 hidden states 를 concatenation 한 벡터를 annotation $h_t$ 으로 정의한다.

$$h_t=[\overrightarrow{h}_t:\overleftarrow{h}_t]$$

Attention 메커니즘은 Encoder-Decoder 의 입력 시퀀스가 단일 벡터로 요약된다는 단점을 보완하기 위해 고안되었으며, 핵심 아이디어는 출력 시점 $t$ 마다 입력 시퀀스 전체를 다시 참조하는 것이다. 즉 디코더의 입력이 하나의 벡터에서, annotation 들의 집합이 된다.

Encoder RNN 이 만든 annotation 의 셋은 아래와 같이 정의된다.

$$H=(h_1, h_2, \dots, h_{T_x})\quad h_i \in \mathbb{R}^{d_h}$$

디코더는 각 출력을 생성할 때 아래와 같은 과정을 거친다.

$$j = 1\dots T_x\\ a(s, h)=v^\top_a\text{tanh}(W_as+U_ah)\\ e_{t, j}=a(s_{t-1}, h_j)\\ \alpha_{t,j} = \frac{\exp(e_{t,j})}{\sum_{k=1}^{T_x} \exp(e_{t,k})}$$

$a(s, h)$ 라는 작은 신경망을 사용하여, 현재 출력 시점 $t$ 에 입력 annotation들에 대한 중요도를 확률 분포 형태 $\alpha_{t,j}$ 로 계산한다.

$$c_t=\sum^{T_x}_{j=1}\alpha_{t,j}h_j$$

각 annotation을 attention weight로 가중합하여 context vector $c_t$를 만든다. 이 식을 풀어서 설명하면, $\alpha_{t,j}$ $t$ 에서 는 $j$ 번째 토큰의 annotation 이 얼마나 중요한지를 의미하고, 이 값은 상수이다. $h_j$ 는 $d_h$ 차원 벡터이며, $a_{t,j}h_j$ 는 $(a_{t,j}h_{j,1}, a_{t,j}h_{j,2}, a_{t,j}h_{j,3},\dots, a_{t,j}h_{j,d_h})$ 이다.

이렇게 각 $a_t$ 가 곱해진 벡터를 전부 $j$ 방향으로 합한다.

$$s_t=g(s_{t-1}, \text{Embed}(y_{t-1}), c_t)$$

이후 이전 시점의 디코더 출력 $y_{t-1}$, 디코더 상태 $s_{t-1}$, 그리고 입력 시퀀스 전체에 대한 attention 정보가 담긴 $c_t$를 이용해 다음 시점의 디코더 상태를 계산한다.

즉, 모든 출력 시점 $t$마다 입력 시퀀스를 요약하는 $c_t$ 를 새로 만들어서, 출력 시 사용하게 된다.

Adam Optimizer

Adam(Adaptive Moment Estimation)은 loss를 감소시키는 gradient의 방향을 1차 모멘트 추정을 통해 관성적으로 유지하고, 동시에 gradient 크기의 변동성을 2차 모멘트 추정을 통해 추적함으로써, 파라미터별로 신뢰도에 기반한 업데이트 크기를 조절하는 최적화 알고리즘이다.

모든 파라미터에 대해 동일한 learning rate를 적용하여 $\theta_{t+1} = \theta_t - \alpha g_t$ 와 같이 업데이트가 이루어진다. 이는 파라미터별 gradient scale이나 변동성을 고려하지 않기 때문에, gradient noise가 크거나 파라미터 간 스케일 차이가 큰 경우 학습이 불안정해질 수 있다.

Adam에서는 시점 $t$에서의 파라미터와 gradient를 다음과 같이 정의한다.

$$\text{parameters}=\theta_t\\ g_t = \nabla_\theta L(\theta_t)\\ \quad\\ m_t=\beta_1m_{t-1}+(1-\beta_1)g_t$$

지수 가중 평균을 이용하여 기울기의 방향을 누적시킨다. 이는 gradient의 평균 방향을 누적하여 추정하는 항으로, noise를 완화하고 일관된 하강 방향을 유지하는 역할을 한다. $\beta_1$ 이 0.9 일 경우 약 10개의 최근 $m_t$ 값들의 평균을 근사한다.

$$v_t=\beta_2v_{t-1}+(1-\beta_2)g^2_t$$

여기서 $g_t^2$는 element-wise square이다.

$v_t$는 gradient 크기의 변동성을 추적하는 항으로, gradient가 얼마나 크게 흔들리는지를 나타내는 지표이며, 해당 방향에 대한 업데이트 크기를 조절하는 데 사용된다. 이는 gradient 방향의 옳고 그름을 판단하기보다는, 해당 방향의 신뢰도를 스케일링하기 위한 정보이다.

$$\hat{m}_t = \frac{m_t}{1-\beta_1^t} \qquad \hat{v}_t = \frac{v_t}{1-\beta_2^t}$$

$m_t$ 와 $v_t$ 모두 지수가중 평균을 사용하므로 $t$ 가 0에 가까우면 0에 대한 편향이 생긴다. $\beta$ 의 $t$ 승을 사용하여 학습 초반에는 거의 $m_t,$ $v_t$ 의 값이 사용되다가, 학습이 진행되며 편향에 대한 보정이 자연스럽게 사라지게 된다.

최종적으로 Adam의 파라미터 업데이트는 다음과 같이 이루어진다:

$$\theta_{t+1} = \theta_t - \alpha \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$$

방향은 평균적으로 이쪽인 것 같긴 한데 step마다 너무 요동친다 → 진짜 경사인지 확신 못 하겠다 → 그러면 조금만 움직이자

Introduction

RNN은 언어 모델링과 기계 번역과 같은 시퀀스 모델링 및 변환 문제에서 효과적인 방법론으로 자리를 잡아왔고, Recurrent 언어 모델과 Encoder-Decoder 구조의 한계를 확장하려는 연구들이 이루어지고 있다.

Recurrent 모델은 일반적으로 시퀀스의 입력 순서에 따라 계산을 나눈다. 위치를 계산 시점으로 간주하므로써, 이전 입력에 대한 hidden state $h_{t-1}$ 와 현재 입력 시점 $t$ 의 입력을 받는 $h_t$ 를 생성한다. → $h_t = f(h_{t-1}, x_t)$

더 나아가 Attention 메커니즘이 등장하고 시퀀스 모델의 핵심 구성요소가 되었다. 이는 기존 순환 모델이 가지고 있던 long-term dependency 표현력 문제를 어느정도 해결했으며, RNN 과 함께 사용되어 성과를 냈다.

하지만 RNN 은 본질적으로 순차적인 특성을 가지며, 이는 내부에서 연산을 병렬화할 수 없음을 의미한다. 또한 역전파 시 시퀀스 전체의 hidden state $h_0 \dots h_n$ 을 모두 저장해야 하므로 메모리 사용량은 시퀀스 길이에 비례하게 되고, GPU 의 메모리는 한정되어 있으므로 무작정 배치 크기를 키울 수 없다.

저자는 이를 해결하기 위해 Recurrence 를 완전히 버리고, Attention 만으로 입-출력 간 관계, 모든 포지션의 관계, 거리에 상관 없는 연결 표현하는 새로운 모델 Transformer 를 제안한다.

Transformer 는 recurrence 기반 sequence modeling 이 아니므로 모든 포지션을 동시에 계산할 수 있어 sequence 내부 병렬화가 가능하고 GPU 친화적으로 연산이 최적화 된다고 주장한다.

또한 Transformer 는 BLEU 기준 SOTA 를 달성하였으며 타 모델에 비해 학습시간을 획기적으로 단축한다.

Related Works

CNN Based Sequence Models

Recurrent 계산을 줄이려는 목표는 Transformer 만의 것이 아니다. CNN 을 기본 블럭으로 사용한 Extended Neural GPU, ByteNet, ConvS2S 와 같은 연구들이 있었고, 1D convolution 연산을 통해 RNN 의 순차성을 제거하고 sequence 내부 병렬화를 목표로 했다.

$$[x_1, x_2, x_3 \dots x_n] \quad x_t \in \mathbb{R}^d \quad d=\text{Embedding Dimension}$$

위와 같은 입력 시퀀스에서 kernel size가 3인 1d convolution 연산은 (경계 처리를 단순화하여 표현하였다):

$$y_t=W_1x_{t-1} + W_2x_t + W_3x_{t+1}$$

이고, 의미적으로 현재 토큰 $x_t$ 은 주변 토큰들과 context 를 형성하여 $y_t$ 를 만들게 되고, 레이어를 쌓으며 한 토큰의 표현이 점점 더 넓은 범위의 시퀀스 정보에 의존하게 된다.

$$y^{(l)}_t=W^{(l)}_1y^{(l-1)}_{t-1}+W^{(l)}_2y^{(l-1)}_{t}+W^{(l)}_3y^{(l-1)}_{t+1}$$

하지만 CNN 기반 모델의 한계는 두 포지션 $i$ 와 $j$ 사이의 정보가 서로 영향을 주려면 여러개의 레이어를 필수적으로 거쳐야 하며, 거리가 멀수록 연산 단계 수(computational path length)가 증가한다는 점이다.

두 포지션 간 정보 전달에 필요한 연산 단계 수를 $O(\cdot)$ 으로 표기한다면, ConvS2S 에서는 $O(|i-j|)$ 이고, ByteNet 은 Dilated 1D convolution 사용, dilation 을 지수적으로 증가시켜 $O(\log|i-j|)$ 이 된다.

이처럼 정보 간의 연결이 거리에 따라 비례하게 되는 단점이 있고, 이는 장거리 의존성 학습을 어렵게 만들며, 모델의 최적화 난이도를 증가시킨다. Transformer 에서는 두 포지션간 정보를 연결하는데 필요한 연산 단계 수는 상수로 줄이는 것을 목표로 한다.

Self-attention

Self-attention(=intra-attention) 은 하나의 시퀀스 내부에서 서로 다른 포지션들 간 관계를 계산해 그 결과로 토큰별 representation 을 만드는 attention 매커니즘이다. 즉 encoder–decoder attention처럼 입력–출력 간 hidden state 참조를 모델링하는 것이 아니라, 시퀀스 내부에서 각 토큰의 관계를 표현하는 방식이다.

Self-Attention 은 Transformer 이전에도 다양한 NLP 태스크에서 성공적으로 사용되어 왔으며, reading comprehension, textual entailment, sentence representation 처럼 문장 내 내부 관계가 중요하고 토큰 간 전역적 상호작용이 중요한 문제에서 특히 좋은 성능을 보였다.

그러나 대부분 입력 시퀀스로부터 하나의 표현을 얻거나 분류를 수행하는 데에 초점이 맞추어져 있었고, 입력 시퀀스를 출력 시퀀스로 변환하는 일반적인 Seq2Seq(transduction) 문제를 직접적으로 다루지는 못했다. 특히 출력이 가변 길이의 시퀀스이며 이전 출력이 이후 출력에 영향을 미치는 생성 구조를 포함하지 않았다는 점에서, 기계 번역과 같은 문제에 일반적으로 적용하기에는 한계가 있었다.

End-to-end Memory Networks

End-to-end 메모리 네트워크는 시퀀스 위치에 맞춰 반복되는 recurrent 가 아니라 attention 을 반복 적용하는 구조를 기반으로 한다. 즉 입력을 순서대로 읽지 않고, 같은 입력 전체에 대해 attention 만 여러번 적용한다.

이런 구조는 단순한 언어 Q/A, 언어 모델링에서는 좋은 성능을 낸다는 것이 증명되었다.

하지만 이러한 모델들은 attention을 여러 번 적용하는 추론 구조를 사용함에도 불구하고, 입력과 출력 시퀀스 간의 일반적인 변환을 수행하는 완전한 Seq2Seq 프레임워크로 확장되지는 않았다. 또한 attention 반복 횟수(hop 수)가 하이퍼파라미터로 고정되어 있으며, 입력과 출력 간의 명시적인 위치 정렬이나 출력 시점별 조건부 생성 구조가 부족하다는 점에서, 복잡한 시퀀스 변환 문제를 해결하는 데에는 제약이 있었다.

Transformer Architecture

현재 성능이 잘 나오는 Seq2Seq 모델들은 대부분 Encoder–Decoder 구조를 사용한다. 여기서 Encoder 는 입력 시퀀스 $x=(x_1, x_2, x_3 \dots x_n)$ 에 대한 annotation $z=(z_1, z_2, z_3 \dots z_n)$ 으로 매핑한다. Decoder 는 주어진 $z$ 에 대해 출력 시퀀스 $y=(y_1, y_2, y_3 \dots y_m)$ 를 한번에 하나씩 생성한다. 각 단계에서 모델은 auto-regressive 하며, 다음 기호 생성할 때 이전에 생성된 기호들을 추가 입력을 사용한다.

Transformer 는 이 전체적인 구조를 따르며, Encoder 와 Decoder 모두에서 여러 층으로 쌓인 self-attention 과 point-wise, FC 레이어들을 사용한다.

Encoder and Decoder

Encoder

Encoder는 $N=6$ 개의 동일한 레이어를 쌓아올린 구조로 구성되며, 각 레이어는 두개의 서브 레이어를 가진다.

첫번째 서브 레이어는 Multi head self-attention 매커니즘이고, 두번째는 간단한 position-wise fully connected feed-forward 네트워크이다.

두 서브 레이어 각각에 대해 residual connection 을 적용하고 layer nomalization 을 적용한다. 즉 각 서브 레이어의 출력은 아래와 같다.

$$\text{LayerNorm(x+\text{SubLayer}(x))}$$

residual connection 을 가능하게 하기 위해 모델 내 모든 서브레이어와 임베딩 레이어는 $d_{model}=512$ 의 출력을 생성한다.

Decoder

Decoder 는 Encoder 와 마찬가지로 $N=6$ 개의 동일한 레이어를 쌓은 구조로 구성된다. Encoder 의 한 레이어 출력에 대해 multi-head attention 을 수행하는 세번째 서브 레이어가 존재한다.

마찬가지로 각 서브레이어는 residual connection 을 사용하고 그 뒤에 Layer Normalization 을 적용한다.

또한 Encoder 와는 다르게 첫번째 서브 레이어는 Masked Multi-Head Attention 을 수행하는데, 이는 학습 시 각 위치가 자기보다 이후의 위치를 참조할 수 없도록 Masking 하는 것을 뜻한다. ****즉 위치 $i$에 대한 예측이 오직 $i$보다 작은 위치의 이미 알려진 출력들에만 의존하도록 보장한다.

Attention

attention 함수는 하나의 Query 와 Key-Value 쌍들의 집합을 입력으로 받아 하나의 출력 벡터로 매핑하는 함수로 설명할 수 있고, Query, Key, Value, 그리고 출력은 모두 벡터이다.

출력은 Value 들의 Weighted sum 으로 계산되며 각 Value 에 할당되는 가중치는 해당 Value 에 대응되는 Key 와 Query 사이의 compatibility function 에 의해 계산된다.

Scaled Dot-Product Attention

저자는 제안하는 attention 메커니즘을 Scaled Dot-Product Attention 이라고 부른다.

입력은 차원이 $d_k$ 인 Query와 Key, 그리고 차원이 $d_v$ 인 Value 로 구성된다. 즉, $d_k\neq d_v$ 일 수 있다. 저자는 Query 와 모든 Key 의 내적을 계산한 뒤 각각 $\sqrt{d_k}$ 로 나누고 softmax 함수로 각 Value 들에 대한 가중치를 얻는다.

실제로는 여러개의 Query 에 대해 Attention 을 동시에 계산하며, 전체 쿼리를 행렬 $Q$ 로 묶는다. Key 와 Value 도 마찬가지로 행렬 $K$ 와 $V$ 로 묶는다.

$$Q\in \mathbb{R}^{n_q\times d_k}\\ K\in \mathbb{R}^{n_k\times d_k}\\ V\in \mathbb{R}^{n_k\times d_v}\\ \text{Attention}(Q, K, V)=\text{softmax}(\frac{QK^\top}{\sqrt{d_k}})V$$

Attention Mechanisms 에서의 구조로 비유하자면, 현재 디코더의 상태 $s_{t-1}$ 에서, 인코더의 모든 annotation 에 대한 중요도를 알기 위해 $j=1\dots T_x$ 범위에서 $a(s_{t-1}, h_j)$ 를 수행했고, 확률 분포로 변환되어 가중합을 계산하였다.

즉 찾고자 하는 것 ($Q$) 은 $s_{t-1}$ 이고, 그것과 비교할 대상($K$) 은 $h_j$ 이 된다. 기존 Attentio n 메커니즘 에서는 비교할 대상과 가지고 오는 값이 같았다면 ($K=V=h$), Transformer는 $Q$와 $K$의 유사도를 기반으로 $V$들을 가중합하여 관련 정보를 추출한다.

위 식에서 $QK^\top$는 각 query 벡터와 모든 key 벡터 간의 내적을 계산한 것으로, 벡터들이 서로 얼마나 유사한 방향을 가리키는지를 나타낸다. query와 방향이 유사한 key일수록 더 큰 값을 가지며, 이를 softmax 함수에 통과시켜 각 key에 대한 중요도 분포를 얻는다. 이후 이 가중치를 value 벡터들에 적용해 가중합을 계산함으로써, query에 가장 관련된 정보를 효과적으로 추출한다.

저자는 여기에서 softmax 함수에 넣기 전에 내적 값을 $\sqrt{d_k}$ 로 나누어 정규화 하는데, 이는 $d_k$ 가 커질수록 내적값의 분산이 증가하여 softmax 출력이 지나치게 뾰족해지기 때문이다. $d_k$ 가 작은 경우에는 두 어텐션 메커니즘이 유사한 성능을 보이지만 $d_k$ 가 커질수록 스케일링이 없는 dot-product attention 은 additive attention 보다 성능이 떨어진다고 주장하며, $d_k$가 클 때 내적 값의 크기가 커져서 softmax 함수가 그래디언트가 극도로 작은 영역으로 밀려난다고 추측한다.

Multi-head Attention

저자는 $d_{\text{model}}$ 차원의 key, value, query 로 하나의 어텐션만 수행하는 대신, 서로 다른 학습된 선형 변환으로 $h$번 투영하여 각각 $d_k, d_k, d_v$ 차원으로 만드는 것이 더 효과적이라고 주장한다.

투영된 각 query, key, value 쌍에 대해 병렬로 attention 을 여러번 수행하여 $d_v$ 차원의 출력을 얻는 것이다. 이 출력들을 concat 한 후 다시 한번 선형 변환하여 최종 출력을 얻는다. 이런 방법을 Multi-Head Attention 이라고 한다.

저자가 주장하는 기존 방법론 (single head-attention) 의 문제점은, 중요도의 관계가 평균화 된다는 것이다.

$$x=\text{FC Bayern München, stern des südens}\\ y=\text{FC Bayern Munich, star of the south}$$

위와같은 번역 입/출력 시퀀스가 있을 때, 출력 시점을 stern 을 star 로 번역해야 하는 타이밍으로 가정한다. single head attention 같은 경우, 중요도 분포는 아래와 비슷할 것이다.

$j$	$\alpha_{t,j}$	$x_j$
1	0.10	FC
2	0.10	Bayern
3	0.20	München
4	0.05	,
5	0.25	stern
6	0.05	des
7	0.15	südens

그리고 이걸 가중합 해서 하나의 context 벡터를 만들게 되는데, 이때 서로 다른 역할의 단어들이 하나의 attention 분포로 평균된다는 것이다. 즉, 주어, 동사, 부사, 목적어 등의 정보를 하나로 묶어서 요약하게 된다.

Multi-head Attention에서는 이 과정을 $h$개의 head에 대해 병렬로 수행함으로써, 모델이 서로 다른 선형 투영 공간에서 다양한 관계를 분리해 학습할 수 있도록 한다. 즉 head 는 서로 다른 선형 투영을 통해 관계를 분리해 학습할 수 있는 독립적인 attention 공간을 의미한다. 이렇게 $h$개의 head 출력을 concatenate한 뒤, 다시 선형 변환을 적용하여 최종 출력 표현을 만든다.

$$\text{MultiHead}(Q, K, V)=\text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O\\ \text{where} \text{ head}_i=\text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$ $$W_i^Q \in \mathbb{R}^{d_{\text{model}} \times d_k},\quad W_i^K \in \mathbb{R}^{d_{\text{model}} \times d_k},\quad W_i^V \in \mathbb{R}^{d_{\text{model}} \times d_v}$$

입력 표현은 항상 $d_{\text{model}}$ 차원이며, 각 head 는 더 작은 $d_k, d_v$ 차원으로 투영한다. $Q, K, V$ 가 head 별로 각각 다른 가중치를 통해 선형 투영되기 때문에, 서로 다른 subspace 를 가지게 된다.

$$W^O\in \mathbb{R}^{hd_v\times{}d_\text{model}}$$

$h$ 개의 $d_v$ 차원을 concat 하면 $hd_v$ 차원이므로, $W^O$ 의 입력 차원은 $hd_v$ 이고 출력 차원을 $d_{\text{model}}$ 로 하여 다시 기존 차원을 복구한다. 이는 언급했던 Residual Connection 을 위해서이다.

저자는 $h=8$ 로, $d_k=d_v=\frac{d_{model}}{h}=64$ 로 설정하였다. 이렇게 하면 head 수는 1에서 $h$ 로 증가하였지만, head 의 차원을 $h$ 로 나눔으로써 어텐션을 여러번 해도 연산량이 single-head attention 과 유사하다고 설명한다.

Applications of Attention in Transformer

Transformer 는 아래 3가지의 서로 다른 방식으로 multi-head attention 을 사용한다.

1. encoder–decoder attention 층에서는, query는 이전 디코더 레이어의 출력에서 나오고, key와 value는 인코더의 출력에서 나온다. 이를 통해 디코더의 각 위치는 입력 시퀀스의 모든 위치에 대해 attention을 수행할 수 있다. 이는 Seq2Seq 모델에서 사용되던 전형적인 encoder–decoder attention 메커니즘을 모방한 것이다.
2. 인코더는 self-attention 레이어를 포함한다. self-attention 레이어에서는 key, value, query가 모두 동일한 출처에서 나오며, 여기서는 인코더의 이전 레이어 출력이다. 인코더의 각 위치는 이전 인코더 레이어의 모든 위치에 대해 attention을 수행할 수 있다. 즉 Encoder self-attention에서는 입력 시퀀스의 각 위치가 동일한 시퀀스 내 모든 다른 위치와의 관계를 모델링함으로써, 전역적인 문맥 표현을 학습한다.
3. 마찬가지로, 디코더의 self-attention 레이어는 디코더의 각 위치가 자기 자신을 포함하여 그 위치까지의 모든 위치에 대해 attention을 수행할 수 있도록 한다. auto-regressive 특성을 유지하기 위해, 디코더에서는 미래 방향(왼쪽이 아닌 오른쪽)으로부터의 정보 흐름을 차단해야 한다. 저자는 이를 scaled dot-product attention 내부에서 구현하는데, softmax의 입력 중 허용되지 않는 연결에 해당하는 값들을 $-\infty$ 로 설정하여 마스킹한다.

$$QK^\top \in \mathbb{R}^{T\times T}\quad (QK^\top)_{i,j} = \begin{cases} (QK^\top)_{i, j} & j \le i \\ -\infty & j > i \end{cases}$$ $$\begin{matrix} & \text{FC}_1 & \text{Bayern}_2 & \text{Munich}_3 & \text{star}_4 & \text{of}_5 & \text{south}_6 \\\text{FC}_1 & (QK^\top)_{1,1} & -\infty & -\infty & -\infty & -\infty & -\infty \\\text{Bayern}_2 & (QK^\top)_{2,1} & (QK^\top)_{2,2} & -\infty & -\infty & -\infty & -\infty \\\text{Munich}_3 & (QK^\top)_{3,1} & (QK^\top)_{3,2} & (QK^\top)_{3,3} & -\infty & -\infty & -\infty \\\text{star}_4 & (QK^\top)_{4,1} & (QK^\top)_{4,2} & (QK^\top)_{4,3} & (QK^\top)_{4,4} & -\infty & -\infty \\\text{of}_5 & (QK^\top)_{5,1} & (QK^\top)_{5,2} & (QK^\top)_{5,3} & (QK^\top)_{5,4} & (QK^\top)_{5,5} & -\infty \\\text{south}_6 & (QK^\top)_{6,1} & (QK^\top)_{6,2} & (QK^\top)_{6,3} & (QK^\top)_{6,4} & (QK^\top)_{6,5} & (QK^\top)_{6,6}\end{matrix}$$

$\exp(-\infty)=0$ 이므로, 내적값이 softmax 를 지나면 0으로 처리되어 마스킹된다.

Position-wise Feed-forward

Attention 서브레이어에 더해, 인코더와 디코더의 각 레이어는 feed-forward 네트워크를 포함한다. 이 네트워크는 각 위치에 대해 독립적으로, 그리고 동일하게 적용된다.

$$x \in \mathbb{R}^{d_{\text{model}}}\\ W_1 \in \mathbb{R}^{d_{\text{model}} \times d_{\text{ff}}}\\ W_2 \in \mathbb{R}^{d_{\text{ff}} \times d_{\text{model}}}$$ $$\text{FFN}(x) = \max(0, xW_1 + b_1)\, W_2 + b_2$$

선형 변환은 서로 다른 위치들에 대해 동일하게 적용되지만, 레이어가 바뀔 때마다 서로 다른 파라미터를 사용한다. 이를 다른 방식으로 표현하면, 커널 크기가 1인 두 개의 convolution 연산으로 볼 수 있다.

입력과 출력의 차원은 $d_{\text{model}}=512$이며, 내부 레이어의 차원은 $d_{ff}=2048$이다.

Position-wise FFN은 각 토큰 위치에 대해 동일한 비선형 변환을 독립적으로 적용함으로써, attention을 통해 수집된 정보를 토큰 단위에서 재해석하고 정제하는 역할을 한다. 이 과정에서 입력 차원 $d_{\text{model}}$을 더 큰 중간 차원 $d_{ff}$로 확장한 뒤 다시 원래 차원으로 축소함으로써, 모델은 더 높은 표현력을 가진 비선형 변환을 학습할 수 있다. 이는 토큰 간 상호작용을 담당하는 attention과 달리, 토큰 내부 표현을 깊게 만드는 역할을 수행한다.

Embedding and Softmax

Transformer는 다른 시퀀스 변환 모델들과 마찬가지로, 입력 토큰과 출력 토큰을 $d_{\text{model}}$ 차원의 벡터로 변환하기 위해 임베딩 레이어의 파라미터 $E$를 학습한다.

또한 디코더의 출력을 다음 토큰의 확률 분포로 변환하기 위해 선형 변환과 softmax 함수를 적용한다. 저자는 Transformer 에서 입력 임베딩, 출력 임베딩, 그리고 softmax 이전 선형 변환이 동일한 가중치 행렬 $E$을 공유하도록 설계하였으며, 이는 기존 연구와 유사한 방식이다.

이때 임베딩 레이어에서는 해당 가중치 $E$에 $\sqrt{d_{model}}$ 스케일링을 적용한다. embedding 은 값의 분산이 작으므로 크기를 키워 attention 출력과 스케일을 맞춘다.

$$E \in \mathbb{R}^{|V| \times d_{\text{model}}}\\$$

• 입력 토큰 시퀀스에 대한 $E$ 사용:

  $$x_t \in \mathbb{R}^{|V|}, \quad (x_t)_i = \begin{cases} 1 & \text{if } i = \text{index}(x_t) \\ 0 & \text{otherwise} \end{cases}\\$$

$$e^{(\text{enc})}_t =\sqrt{d_{\text{model}}}\; x_t^\top E$$

• 출력 임베딩에 대한 $E$ 사용:

$$e^{(\text{dec})}_{t-1} = \sqrt{d_{\text{model}}}\; y_{t-1}^\top E$$

• Softmax 이전 선형 변환에서의 $$$E$ 사용:

$$o_t = E^\top s_t \in \mathbb{R}^{|V|}\\ P(y_t \mid y_{<t}, x) = \text{softmax}(o_t)$$

Transformer는 모델 정의 상 입력 임베딩, 출력 임베딩, 그리고 softmax 이전 선형 변환에서 동일한 가중치 행렬 $E$를 공유하며, 이 공유된 파라미터는 학습 과정 전반에 걸쳐 업데이트된다.

Positional Encoding

Transformer 는 순환 구조도 없고, convolution 연산도 없기 때문에 모델이 시퀀스의 순서 정보를 활용할 수 있도록 토큰들의 상대적 혹은 절대적 위치에 대한 정보를 주입하여야 한다. 이를 위해 입력 입베딩 시 Positional Encoding 을 더한다.

Positional Encoding 은 임베딩과 동일한 $d_{\text{model}}$ 차원이며, 두 벡터를 덧셈으로 결합할 수 있다.

저자는 인코딩에 두가지 방법론이 있다고 설명하는데, 학습 가능한 방식과 고정된 방식이 있다. 본 논문에서는 서로 다른 주파수를 갖는 sine, cosine 함수를 사용한다.

$$\begin{aligned} PE(pos, 2i) &= \sin\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) \\ PE(pos, 2i+1) &= \cos\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) \end{aligned}$$

$pos$ 는 토큰이 문장에서 몇번째 위치인지, $i$ 는 벡터 안에서 몇번째 차원인지를 의미한다. 포지셔널 인코딩의 각 차원은 하나의 사인/코사인 파형에 해당한다.

식에서 삼각함수의 파장은 $2\pi$ 부터 $10000\times 2\pi$ 까지 지수적으로 증가한다.

positional encoding 벡터는 여러 주파수 성분으로 구성되어 있으며, 저차원에서는 짧은 파장, 고차원에서는 긴 파장의 신호가 사용된다.

저자는 이 함수를 선택하게 된 것이 모델이 상대적 위치에 기반한 attention 을 쉽게 학습할 것이라고 가정했기 때문이라고 설명하며, 실제로 positional embedding 을 학습시켜보았으나 성능은 거의 같았다고 주장한다. 또한 학습시키는 positional embedding 을 사용할 때 보다 삼각함수로 구현할 때의 이점은 학습 때보다 더 긴 문장에도 적용될 가능성이 있기 때문이다.

어떤 고정된 거리 $k$ (position 상 거리를 의미한다.) 에 대해, $PE(pos+k)$ 는 $PE(pos)$ 의 선형 함수로 표현할 수 있다. 이것을 증명하기 위해 512 차원이 아니라 2 차원의 경우를 예로 들어 보자면:

$$PE(pos)= \begin{bmatrix} \sin(\omega pos)\\ \cos(\omega pos) \end{bmatrix}$$

이고, $pos+k$ 의 Positional Encoding 은:

$$PE(pos+k) = \begin{bmatrix} \sin(\omega (pos+k)) \\ \cos(\omega (pos+k)) \end{bmatrix}$$

에서, 삼각함수 덧셈 공식에 의해:

$$\begin{aligned} \sin(\omega(pos+k)) &= \sin(\omega pos)\cos(\omega k) + \cos(\omega pos)\sin(\omega k) \\ \cos(\omega(pos+k)) &= \cos(\omega pos)\cos(\omega k) - \sin(\omega pos)\sin(\omega k) \end{aligned}$$ $$\begin{bmatrix} \sin(\omega(pos+k)) \\ \cos(\omega(pos+k)) \end{bmatrix} = \begin{bmatrix} \cos(\omega k) & \sin(\omega k) \\ -\sin(\omega k) & \cos(\omega k) \end{bmatrix} \begin{bmatrix} \sin(\omega pos) \\ \cos(\omega pos) \end{bmatrix}$$

이다. 즉 $PE(pos+k)=M_k \cdot PE(pos)$ 이고, $M_k$ 는 오직 offset $k$ 와 주파수 $\omega$ 에만 의존한다. 곧 이 성질로 인해 self-attention과 같은 선형 연산 기반 구조에서 상대적 위치 관계를 쉽게 학습할 수 있다.

Model Formula

• 주의:

  수식의 가독성을 위해 인코더와 디코더의 각 레이어 $l$ 에 대해 $W^{O,(l)}_{\text{enc}}, W^{Q,(l)}{_\text{dec}}$ 와 같이 표기하지 않고 통일하여 $W^O, W^Q, W^K, W^V$ 등으로 표기한다. 그러나 실제 모델에서는 인코더/디코더의 각 레이어 및 각 서브 레이어 (Self-Attention, Cross-Attention, FFN)의 파라미터는 모두 서로 독립적이며, 임베딩 파라미터 $E$만이 공유된다.

  또한 수식은 학습용 수식을 전제로 작성했고, 학습 시에는 고정된 길이의 타깃 시퀀스를 병렬 처리하므로 미래 토큰을 차단하기 위한 causal mask가 필요하다. 반면 추론 시에는 디코더 입력이 현재까지 생성된 토큰만 포함하므로 마스크는 전부 0이거나 생략될 수 있다.

1. Set-up

$$N=6\\ d_{\text{model}}=512\\ h=8\\ d_k=d_v=\frac{d_{\text{model}}}{h}=64\\ d_{ff}=2048\\ E \in \mathbb{R}^{|V| \times d_{\text{model}}}\\$$

1. Input Embedding

$$x = [x_1, x_2, \dots, x_{T_x}],\quad x_i \in \mathbb{R}^{|V|} \\\quad\\ e^{(\text{enc})} = \sqrt{d_{\text{model}}} \begin{bmatrix} x_1^\top E\\ x_2^\top E\\ \vdots\\ x_{T_x}^\top E \end{bmatrix} \in \mathbb{R}^{T_x \times d_{\text{model}}}$$

1. Positional Encoding

$$H_{enc}^{(0)}=e^{(\text{enc})}_{\text{PE}} = e^{(\text{enc})} + \begin{bmatrix} PE(0)\\ PE(1)\\ \vdots\\ PE(T_x-1) \end{bmatrix}$$

1. Encoder Self-Attention

$$i=1\dots h$$ $$W_i^Q \in \mathbb{R}^{d_{\text{model}} \times d_k}\quad W_i^K \in \mathbb{R}^{d_{\text{model}} \times d_k}\quad W_i^V \in \mathbb{R}^{d_{\text{model}} \times d_v}$$ $$Q_i = H_{enc}^{(0)} W_i^Q \in \mathbb{R}^{T_x \times d_k}\\ K_i = H_{enc}^{(0)} W_i^K \in \mathbb{R}^{T_x \times d_k}\\ V_i = H_{enc}^{(0)} W_i^V \in \mathbb{R}^{T_x \times d_v}$$ $$\text{head}_i=\text{Attention}(Q_i,K_i,V_i) = \text{softmax}\!\left( \frac{Q_i K_i^\top}{\sqrt{d_k}} \right)V_i$$ $$W^O\in \mathbb{R}^{hd_v\times{}d_\text{model}}$$ $$\text{SA}=\text{MultiHead}(H_{enc}^{(0)}, H_{enc}^{(0)}, H_{enc}^{(0)})=\text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O\\$$ $$\text{SA} \in \mathbb{R}^{T_x \times d_{\text{model}}}$$

1. Residual Connection + LayerNorm

$$\text{SA}_{\text{out}} = \text{LayerNorm}\!\left( e^{(\text{enc})}_{\text{PE}} + \text{SA} \right)$$

1. Position Wise Feed-Forward Network

$$i=1\dots T_x$$ $$(\text{SA}_{out})_i \in \mathbb{R}^{d_{\text{model}}}\\ W_1 \in \mathbb{R}^{d_{\text{model}} \times d_{\text{ff}}}\\ W_2 \in \mathbb{R}^{d_{\text{ff}} \times d_{\text{model}}}$$ $$\text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 \\ \text{FFN}_{raw} = \begin{bmatrix} \text{FFN}((\text{SA}_{\text{out}})_1)\\ \vdots\\ \text{FFN}((\text{SA}_{\text{out}})_{T_x}) \end{bmatrix} \in \mathbb{R}^{T_x \times d_{\text{model}}}$$

1. Residual Connection + LayerNorm

$$H^{(1)}=\text{FFN}_{out}=\text{LayerNorm}\!\left( \text{SA}_{out} + \text{FFN}_{raw} \right)$$

1. repeat $N=6$ times

$$\text{EncoderLayer}(X) = \begin{aligned} Y &= \text{LayerNorm}(X + \text{MultiHead}(X,X,X))\\ Z &= \text{LayerNorm}(Y + \text{FFN}(Y)) \end{aligned}$$ $$H_{enc}^{(l)} = \text{EncoderLayer}(H^{(l-1)}_{enc}), \quad l = 1,\dots,N$$ $$H^{(N)}_{enc} \in \mathbb{R}^{T_x \times d_{\text{model}}}$$

1. Output Embedding

$$y = [\langle\text{SOS}\rangle,y_1, y_2, \dots, y_{T_y-1}],\quad y_i \in \mathbb{R}^{|V|} \\\quad\\ e^{(\text{dec})} = \sqrt{d_{\text{model}}} \begin{bmatrix} \langle\text{SOS}\rangle^\top E\\ y_1^\top E\\ y_2^\top E\\ \vdots\\ y_{T_y-1}^\top E \end{bmatrix} \in \mathbb{R}^{T_y \times d_{\text{model}}}$$

1. Positional Encoding

$$H^{(0)}_{dec}=e^{(\text{dec})}_{\text{PE}} = e^{(\text{dec})} + \begin{bmatrix} PE(0)\\ PE(1)\\ \vdots\\ PE(T_y-1) \end{bmatrix}$$

1. Masked Self-Attention

$$i=1\dots h$$ $$W_i^Q \in \mathbb{R}^{d_{\text{model}} \times d_k}\quad W_i^K \in \mathbb{R}^{d_{\text{model}} \times d_k}\quad W_i^V \in \mathbb{R}^{d_{\text{model}} \times d_v}$$ $$Q_i = H^{(0)}_{dec} W_i^Q \in \mathbb{R}^{T_y \times d_k}\\ K_i = H^{(0)}_{dec} W_i^K \in \mathbb{R}^{T_y \times d_k}\\ V_i = H^{(0)}_{dec}W_i^V \in \mathbb{R}^{T_y \times d_v}$$ $$M_{t, j}=\begin{cases} 0 & \text{if } j\le t \\ -\infty & \text{if } j\gt t \end{cases} \quad \in \mathbb{R}^{T_y \times T_y} \\ \text{head}_i=\text{MaskedAttention}(Q_i,K_i,V_i, M) = \text{softmax}\!\left( \frac{Q_i K_i^\top}{\sqrt{d_k}}+M \right)V_i$$ $$W^O\in \mathbb{R}^{hd_v\times{}d_\text{model}}$$ $$\text{MSA}=\text{MultiHead}(H^{(0)}_{dec}, H^{(0)}_{dec}, H^{(0)}_{dec})=\text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O\\$$ $$\text{MSA} \in \mathbb{R}^{T_y \times d_{\text{model}}}$$

1. Residual Connection + LayerNorm

$$\text{MSA}_{\text{out}}= \text{LayerNorm}\!\left( H^{(0)}_{dec} + \text{MSA} \right)$$

1. Cross Attention

$$i=1\dots h$$ $$Q_i = \text{MSA}_{out} W_i^Q \in \mathbb{R}^{T_y \times d_k}\\ K_i = H^{(N)}_{enc} W_i^K \in \mathbb{R}^{T_x \times d_k}\\ V_i = H^{(N)}_{enc}W_i^V \in \mathbb{R}^{T_x \times d_v}$$ $$\text{head}_i=\text{Attention}(Q_i,K_i,V_i) = \text{softmax}\!\left( \frac{Q_i K_i^\top}{\sqrt{d_k}} \right)V_i$$ $$W^O\in \mathbb{R}^{hd_v\times{}d_\text{model}}$$ $$\text{CA}=\text{MultiHead}(\text{MSA}_{out}, H^{(N)}_{enc}, H^{(N)}_{enc})=\text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O\\$$ $$\text{CA} \in \mathbb{R}^{T_y \times d_{\text{model}}}$$

1. Residual Connection + LayerNorm

$$\text{CA}_{\text{out}}= \text{LayerNorm}\!\left( \text{MSA}_{out} + \text{CA} \right)$$

1. Position Wise Feed-Forward Network

$$i=1\dots T_y$$ $$(\text{CA}_{out})_i \in \mathbb{R}^{d_{\text{model}}}\\ W_1 \in \mathbb{R}^{d_{\text{model}} \times d_{\text{ff}}}\\ W_2 \in \mathbb{R}^{d_{\text{ff}} \times d_{\text{model}}}$$ $$\text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 \\ \text{FFN}_{raw} = \begin{bmatrix} \text{FFN}((\text{CA}_{\text{out}})_1)\\ \vdots\\ \text{FFN}((\text{CA}_{\text{out}})_{T_y}) \end{bmatrix} \in \mathbb{R}^{T_y \times d_{\text{model}}}$$

1. Residual Connection + LayerNorm

$$H^{(1)}_{dec}=\text{FFN}_{out}=\text{LayerNorm}\!\left( \text{CA}_{out} + \text{FFN}_{raw} \right)$$

1. repeat $N=6$ times

$$H^{(0)}_{\text{dec}} = e^{(\text{dec})}_{\text{PE}}$$ $$l=1,\dots,N \\ \begin{aligned}\tilde{H} &= \text{LayerNorm}\big(H^{(l-1)}_{\text{dec}} + \text{MaskedAttention}(H^{(l-1)}_{dec}, H^{(l-1)}_{dec}, H^{(l-1)}_{dec},M)\big) \\\hat{H} &= \text{LayerNorm}\big(\tilde{H} + \text{CrossAttention}(\tilde{H}, H^{(N)}_{\text{enc}}, H^{(N)}_{\text{enc}})\big) \\H^{(l)}_{\text{dec}} &= \text{LayerNorm}\big(\hat{H} + \text{FFN}(\hat{H})\big)\end{aligned}$$ $$H^{(N)}_{dec} \in \mathbb{R}^{T_y \times d_{\text{model}}}$$

1. Embedding and softmax

$$o_t = (H^{(N)}_{\text{dec}})_tE^\top \in \mathbb{R}^{|V|}\\P(y_t \mid y_{<t}, x) = \text{softmax}(o_t)$$

Why Self-Attention

저자는 이 절에서 시퀀스 $(x_1,\dots,x_n)$를 동일한 길이의 또 다른 시퀀스 $(z_1,\dots,z_n)$로 변환하는 데 일반적으로 사용되는 순환(recurrent) 레이어와 합성곱(convolutional) 레이어를 self-attention 레이어의 여러 측면과 비교한다. (여기서, $x_i, z_i \in \mathbb{R}^d$)

Self-Attention 이 다른 방법론과 비교하여 크게 세가지 이점이 있는데, 하나는 레이어 당 연산 복잡도의 우위이고, 또 하나는 병렬화 될 수 있는 계산의 양으로, 이는 필요한 최소 순차 연산의 개수로 측정한다. 즉 선행되어야하는 연산이 얼마나 있는가가 병렬화 가능성을 의미한다.

마지막 세번째는 장거리 의존성을 연결하는 경로의 길이이다. 장거리 의존성을 학습하는 것은 많은 시퀀스 변환 문제에서 핵심적인 어려움이며, 순전파 및 역전파 신호가 네트워크를 통해 이동해야 하는 경로의 길이를 의미하기 때문이다. 입력과 출력 시퀀스의 어떤 위치 쌍에 대해서든, 이 경로가 짧을수록 장거리 의존성을 학습하기가 더 쉬워진다.

따라서 저자는 서로 다른 레이어 타입(RNN, CNN, self-attention)으로 구성된 네트워크에서, 임의의 두 입력/출력 위치 사이의 최대 경로 길이를 비교한다.

vs. RNN

self-attention 레이어는 모든 위치를 상수 개수의 순차 연산으로 연결하는 반면, recurrent 레이어는 $O(n)$개의 순차 연산이 필요하다. 계산 복잡도 측면에서 보면, 시퀀스 길이 $n$이 표현 차원 $d$보다 작을 때 self-attention 레이어는 recurrent 레이어보다 빠르다.

RNN 에서 hidden state 를 계산하기 위해 $W_hh_{t-1}$ 를 계산하는데, 여기서 $W_h\in \mathbb{R}^{d\times d}$ 이므로, 계산 복잡도는 $O(d^2)$ 이며, $n$ 스텝을 계산해야하므로 RNN 의 계산 복잡도는 $O(n\cdot d^2)$ 이다.

Self-Attention 은 $QK^\top$ 에서 $Q, K\in \mathbb{R}^{n\times d}$ 이다. 즉 행렬 곱에서 각 원소 계산 비용은 $d$ 이고 원소는 $n^2$ 이므로 $O(n^2\cdot d)$ 이다. 곧:

$$n < d\\ \text{RNN} \rightarrow O(n \cdot d^2)\\ \text{SelfAttention} \rightarrow O( n^2\cdot d)\\ n^2d\lt nd^2$$

이기 때문에, $n<d$ 에서 Self-Attention 이 RNN 보다 계산 복잡도가 낮다.

아주 긴 시퀀스를 다루는 작업의 계산 성능을 개선하기 위해 self-attention을 출력 위치를 중심으로 한 크기 $r$의 이웃 영역만 고려하도록 제한할 수도 있다. 이렇게 하면 최대 경로 길이는 $O(n/r)$로 증가하는데, 이 접근법은 본 논문에서는 더 연구되지는 않는다.

vs. CNN

커널 폭이 $k < n$ 인 단일 convolution 레이어는 입력과 출력 위치의 모든 쌍을 연결하지 못한다. 이를 달성하려면 연속된 커널을 사용하는 경우 $O(n/k$)개의 합성곱 레이어를 쌓아야 한다. 혹은 dilated convolution의 경우에는 $O(\log_k n)$개의 레이어가 필요하다. 또한 동일한 표현 차원에서, 커널 폭이 $k$인 convolution은 한 시점당 $k$개의 입력을 처리하므로 순환 레이어보다 일반적으로 $k$배 많은 연산을 요구한다.

하지만 separable convolution 로 계산 복잡도를 상당히 줄일 수 있는데, 먼저 각 채널을 독립적으로 $k$ 로 convolution 한다. 이는 $X \in \mathbb{R}^{n\times d}$ 에서 각 채널 $c$ 에 대해 $X_{i, c}$ 에 대해서만 convolution 하는 것을 의미한다. 즉 요소 갯수 $n\times d$ 개 에서, 각 요소마다 곱셈 $k$ 회 이므로 $O(n\cdot k \cdot d)$),

이후 kernel size 1의 point wise convolution을 적용하여 채널 방향으로 선형 결합한다. 선형 결합은 $XW$ 를 의미하는데, $X \in \mathbb{R}^{n\times d}, W \in \mathbb{R}^{d \times d}$ 이므로, 원소 갯수 $d^2$, 원소 당 연산 $n$ 개이므로, $O(n\cdot d^2)$.

결론적으로 separable convolution 의 계산 복잡도는 $O(k\cdot n \cdot d + n \cdot d^2)$. 그러나 $k = n$ 인 경우에 분리 합성곱의 계산 복잡도는 self-attention 레이어와 point wise feed-forward 레이어를 결합한 것과 동일하다.

즉 CNN 으로 Self-Attention 의 path length 에 도달하려면 $k=n$ 이어야 하며, 이 경우 계산 복잡도는 self-attention + point-wise feed forward 와 동일하다는 것이다.

Side Benefit

부수적인 이점으로, self-attention은 더 해석하기 쉽다. 저자는 모델에서 나온 attention 분포를 분석하였고, 개별 attention head 들이 서로 다른 역할을 학습한다는 점을 시각화를 통해 관찰하였고 많은 head들이 문장의 syntactic 및 semantic 구조와 관련된 행동이 보인다고 주장한다.

즉 Self-attention은 단순히 성능이 좋은 구조일 뿐 아니라, attention weight를 통해 모델이 무엇을 보고 판단하는지 비교적 명확하게 해석할 수 있는 구조다.

Training

Tokenizers

Byte-Pair Encodoing

BPE는 단어를 문자 단위에서 시작해, 가장 자주 함께 등장하는 문자(또는 서브워드) 쌍을 반복적으로 병합하여 서브워드 어휘를 만드는 빈도 기반 토크나이징 기법이다.

학습 과정은 단순히 말뭉치에서 가장 빈번한 쌍을 찾고 이를 하나의 토큰으로 합치는 작업을 정해진 횟수만큼 반복하는 방식이며, 이로써 어휘 크기를 제한하면서도 희귀 단어를 여러 서브워드의 조합으로 표현할 수 있다. BPE는 계산이 간단하고 데이터 규모가 크지 않아도 안정적으로 동작하기 때문에, WMT 영어–독일어 번역과 같이 비교적 중간 규모 데이터에서 표준적으로 사용되어 왔다.

playing, played, player, plays

의 예시에서, p + l, pl + a, pla + y 같이 자주 같이 등장하는 문자쌍 위주로 병합하는 방식이다.

WordPiece

WordPiece는 단어를 서브워드 단위로 분해한다는 점에서는 BPE와 유사하지만, 병합 기준으로 단순 빈도가 아니라 언어 모델의 확률($\log$ likelihood)을 가장 크게 개선하는 쌍을 선택하는 확률 기반 토크나이징 기법이다.

즉, 두 토큰을 합쳤을 때 문장 전체의 생성 확률이 얼마나 좋아지는지를 기준으로 병합을 결정한다. 이 때문에 WordPiece는 이론적으로 더 정교한 기준을 사용하지만, 충분한 데이터가 있을 때 효과적이며 학습 비용은 BPE보다 다소 높다.

playing, played, player, plays

의 예시에서, play + (ing, ed, er) 일 때 모델이 likelihood 를 최대로 만드므로, play라는 서브워드를 만들었을 때 전체 문장 확률이 올라가면, 그 병합을 채택한다.

Training Data and Batching

WMT 2014 번역 벤치마크에서 저자는 두 가지 데이터셋으로 Transformer를 학습했다. 영어-독일어는 약 450만 개의 문장 쌍으로 구성된 표준 WMT14 데이터를 사용했고, 영어-프랑스어는 훨씬 규모가 큰 3,600만 문장 쌍의 WMT14 데이터를 사용했다. 두 실험 모두 단어를 그대로 쓰지 않고, 희귀 단어를 더 작은 단위로 쪼개는 서브워드 토크나이징을 적용했다. 영어-독일어에서는 Byte-Pair Encoding(BPE)을 사용해 소스와 타깃이 공유하는 약 37,000개 토큰 어휘를 만들었고, 영어-프랑스어에서는 word-piece 방식으로 약 32,000개 토큰 어휘를 사용했다. 이런 서브워드 기반 어휘를 쓰면 OOV(어휘 밖 단어) 문제가 줄고, 언어 간 형태 변화가 큰 단어도 조합적으로 표현할 수 있다.

BPE 는 빈도 기반이므로, 데이터가 아주 크지 않아도 안정적으로 동작한다. 병합 기준이 단순하기 때문이다. 반면 WordPiece 는 확률 기반이므로, 충분히 큰 말뭉치가 있어야 병합 판단이 의미있다. 즉 데이터가 적으면 불안정 할 수 있다. 그래서 불어에 비해 데이터가 적은 독일어 쪽에 BPE 를 사용했다고 해석된다.

저자는 배치 구성 방식도 Transformer 특성에 맞춰 설계했다. 문장 수를 고정해서 배치를 만드는 대신, 문장 쌍을 대략 비슷한 길이끼리 묶은 뒤 한 배치가 포함하는 토큰 수를 거의 일정하게 맞췄다. 구체적으로는 한 배치가 대략 소스 토큰 25,000개와 타깃 토큰 25,000개를 포함하도록 문장 쌍을 모았다. 이렇게 하면 길이가 제각각인 문장을 무작정 섞었을 때 발생하는 과도한 padding 낭비가 줄어들고, 특히 시퀀스 길이에 따라 비용이 커지는 self-attention(대략 $O(n^2)$)을 더 효율적으로 학습할 수 있다.

Hardware and Schedule

저자는 8개의 P100 GPU 환경에서 Transformer를 학습했으며, base 모델은 약 12시간, big 모델은 약 3.5일이 소요되었다. 이는 Transformer가 병렬화에는 유리하지만, 대규모 연산 자원을 전제로 한 모델임을 보여준다.

Optimizer

저자는 Adam 옵티마이저를 사용했으며, 1차 모멘트 계수는 $\beta_1 = 0.9$, 2차 모멘트 계수는 $\beta_2 = 0.98$, 수치 안정화를 위한 상수는 $\epsilon=10^{-9}$로 설정했다.

보편적으로 사용하는 $\beta_2=0.999$ 를 사용하지 않은 것이 포인트인데, $0.98$ 은 훨씬 빠른 분산 반응을 보인다. 이는 Transformer 에서 attention score 분포가 step 마다 크게 변하기 때문이며, 특정 head, token 에 몰렸다가 사라져 과거의 분산 정보가 금방 쓸모없어지기 때문이다.

또한 학습 과정 전체에 걸쳐 학습률을 변화시켰다.

$$\text{lrate} = d_{\text{model}}^{-0.5} \cdot \min\left( \text{step}^{-0.5}, \text{step}\cdot \text{warmup\_steps}^{-1.5} \right)$$

Transformer는 학습 초반 불안정을 막기 위해 처음 4000 step 동안 학습률을 step에 비례해 선형적으로 증가시키고, 이후에는 step 수의 역제곱근에 비례하도록 감소시키는 learning rate schedule을 사용한다.

Regularization

Residual Dropout

Transformer에서는 각 서브레이어의 출력에 dropout을 적용한 뒤 residual connection과 layer normalization을 수행하는 residual dropout을 사용한다. 이는 identity path의 안정성을 유지하면서 서브레이어 출력에만 정규화를 가하기 위함이다.

$$\text{LayerNorm}\big(x + \text{Dropout}(\text{Sublayer}(x))\big)$$

또한 입력 단계에서 token embedding과 positional encoding의 합에도 dropout을 적용하여 위치 정보에 대한 과도한 의존을 방지한다. Base 모델에서는 dropout 비율로 0.1을 사용한다.

$$H^{(0)} = \text{Dropout}(E(x) + PE(x))$$

Label Smoothing

퍼플렉시티(perplexity)는 언어 모델이 정답 토큰을 얼마나 “확신하지 못하는지”를 나타내는 지표로, 각 시점에서 정답 단어에 할당한 로그 확률의 평균을 지수화한 값이다. 직관적으로는 모델이 다음 단어를 예측할 때 평균적으로 몇 개의 후보 앞에서 망설이고 있는지를 의미하며, 값이 낮을수록 모델이 정답에 높은 확률을 부여하고 있음을 뜻한다.

라벨 스무딩(label smoothing)은 학습 시 정답 레이블을 one-hot 벡터로 두지 않고, 정답 클래스의 확률을 1보다 작게 낮추고 나머지 확률을 다른 클래스들에 소량 분산시키는 정규화 기법이다. 이로 인해 모델은 특정 토큰에 대해 100% 확신을 갖도록 강제되지 않으며, 출력 분포가 지나치게 뾰족해지는 것을 방지한다. 결과적으로 모델은 “정답일 가능성이 가장 높다”는 정보는 유지하되, 대안 토큰들에 대해서도 일정 수준의 확률을 할당하도록 학습된다. 이는 over-confidence를 줄이고, softmax 출력의 포화를 방지하는 역할을 하며, 출력 분포 자체에 작용하는 regularization으로 볼 수 있다.

저자는 학습 과정에서 라벨 스무딩($\epsilon_{ls} = 0.1$)을 적용하였으며, 이로 인해 퍼플렉시티는 오히려 악화되지만 정확도와 BLEU 점수는 향상된다고 보고한다. 이는 라벨 스무딩이 정답 토큰의 확률을 의도적으로 낮추기 때문에 퍼플렉시티 기준에서는 손해처럼 보이지만, 번역 과제에서 중요한 것은 단일 토큰의 확률 최대화가 아니라 문장 전체의 상대적 품질이기 때문이다.

Results

Machine Translation

저자는 Transformer 논문에서 저자들은 WMT 2014 영어–독일어와 영어–프랑스어 번역 과제를 통해 모델의 성능과 효율성을 평가하였다. 영어–독일어 번역에서는 약 450만 문장 쌍으로 구성된 데이터셋을 사용했으며, Transformer(big) 모델은 BLEU 28.4를 기록해 기존 최고 성능 모델들(앙상블 포함)을 2 BLEU 이상 앞지르며 새로운 최고 성능을 달성했다. 영어–프랑스어 번역에서는 3,600만 문장으로 이루어진 훨씬 더 큰 데이터셋을 사용했으며, Transformer(big)은 BLEU 41.0을 기록해 기존 모든 단일 모델을 능가했고, 이전 최고 성능 모델 대비 훈련 비용은 1/4 이하에 불과했다. 심지어 base 모델조차도 기존의 모든 단일 모델과 앙상블을 뛰어넘는 성능을 훨씬 적은 계산 비용으로 달성했다.

base 모델과 대부분의 실험에서는 dropout 비율 0.1을 적용했다. 반면 Transformer(big)은 기본적으로 파라미터 수가 많아 과적합 위험이 크기 때문에 dropout 0.3을 사용했지만, 데이터 규모가 매우 큰 영어–프랑스어 번역 실험에서는 과도한 정규화를 피하기 위해 dropout을 0.1로 낮췄다. 이는 모델 크기뿐 아니라 데이터 규모에 따라 적절한 정규화 강도가 달라져야 함을 보여준다.

Model Variations

저자는 Transformer의 각 구성 요소가 성능에 미치는 영향을 분석하기 위해, base 모델을 다양한 방식으로 변형하는 테스트를 수행하였다. 평가는 영어–독일어 번역 개발셋(newstest2013)에서 이루어졌으며, beam search는 사용하되 checkpoint averaging은 적용하지 않았다.

• multi-head attention의 중요성이 확인되었다. 단일 head attention은 최적 설정 대비 약 0.9 BLEU 낮은 성능을 보였으며, 이는 여러 head를 통해 서로 다른 관계를 병렬적으로 학습하는 구조가 번역 성능에 실질적으로 기여함을 의미한다. 다만 head 수를 지나치게 늘릴 경우 각 head의 차원이 너무 작아져 성능이 다시 저하되었다.
• attention key 차원 $d_k$ 은 모델 성능에 중요한 요소였다. $d_k$를 줄이면 번역 품질이 감소했는데, 이는 query–key 간의 유사도를 판단하는 문제가 단순하지 않으며 충분한 표현 공간이 필요함을 시사한다.
• 모델 크기와 정규화의 효과도 명확히 나타났다. 모델을 크게 만들수록 성능은 향상되었고, dropout은 과적합을 방지하는 데 매우 중요한 역할을 했다. 특히 Transformer처럼 파라미터 수가 많은 모델에서는 dropout이 없을 경우 성능이 크게 악화되었다.
• positional encoding 방식에 대한 실험에서는 사인-코사인 기반 고정 positional encoding과 학습 가능한 positional embedding 사이에 성능 차이가 거의 없었다. 이는 Transformer가 고정된 위치 인코딩만으로도 충분히 위치 정보를 활용할 수 있음을 보여준다.

English Constituency Parsing

저자는 Transformer가 기계 번역을 넘어 다른 시퀀스 변환 문제에도 일반화될 수 있는지를 검증하기 위해 영어 구문 분석(constituency parsing) 실험을 수행하였다. 구문 분석은 출력이 강한 구조적 제약을 따르고 출력 시퀀스가 입력보다 훨씬 길어지는 어려운 과제로, 모델의 장거리 의존성 처리 능력과 구조적 표현력을 평가하기에 적합하다.

실험 결과, Transformer는 과제 특화된 구조나 복잡한 튜닝 없이도 매우 우수한 성능을 보였으며, 기존 RNN 기반 sequence-to-sequence 모델들을 모두 능가하였다. 특히 데이터 규모가 작은 환경에서도 전통적인 구문 분석 모델인 Berkeley Parser보다 더 나은 성능을 기록하였다. 이는 self-attention 기반 Transformer가 장거리 의존성과 전역적 구조를 효과적으로 모델링할 수 있음을 보여주며, Transformer가 번역을 넘어 다양한 구조적 시퀀스 변환 문제에서도 강한 일반화 성능을 갖는다는 점을 입증한다.

Conclusion

저자는 본 논문에서 Transformer를 제안하였다. Transformer는 기존 encoder–decoder 구조에서 널리 사용되던 순환(recurrent) 레이어를 완전히 제거하고, multi-head self-attention만으로 구성된 최초의 시퀀스 변환 모델이다.

기계 번역 실험에서 Transformer는 RNN이나 CNN 기반 모델들에 비해 훨씬 빠르게 학습될 수 있었으며, WMT 2014 영어–독일어 및 영어–프랑스어 번역 과제 모두에서 SOTA를 달성하였다. 특히 영어–독일어 번역에서는 기존의 모든 앙상블 모델들까지도 능가하는 성능을 기록하였다.

저자들은 이러한 결과를 바탕으로 attention 기반 모델의 잠재력에 큰 기대를 표하며, 향후 Transformer를 텍스트를 넘어 이미지, 오디오, 비디오와 같은 다양한 입력·출력 모달리티로 확장할 계획임을 밝힌다. 또한 매우 큰 입력과 출력을 효율적으로 처리하기 위해 국소적(local) 또는 제한된 attention 메커니즘을 연구하고, 생성 과정의 순차성을 더욱 줄이는 방향도 중요한 향후 연구 과제로 제시한다.