[논문리뷰] Attention Is All You Need

Overview

논문명: Attention Is All You Need
학회(출판연도): NeurIPS (2017)
연구분야: 딥러닝 기반 시퀀스 모델링 및 자연어 처리

---

Abstract(초록)

✓ 지난주 복습~

✓ 기존 시퀀스 변환 모델

• 인코더와 디코더를 포함하는 복잡한 순환신경망(RNN) 기반
• 합성곱 신경망 기반
• [SOTA]: 어텐션 매커니즘을 통해 인코더와 디코더를 연결하기도 함

✓ 어텐션 매커니즘을 통해 인코더와 디코더를 연결한다.

→ 디코더가 단순히 인코더의 마지막 hidden state 하나만 참고하는 게 아니라, 인코더 전체 출력(hidden state sequence)을 보고 필요한 정보를 가중치로 뽑아온다.

---

✓ Attention이 없는 경우 vs 있는 경우 (RNN Seq2Seq)

• Attention이 없는 경우

  • 인코더는 입력 시퀀스를 다 읽고, 마지막 hidden state 하나를 context vector로 만들어 디코더로 전달
  • 긴 문장일수록 정보가 압축되면서 정보 손실 발생

• Attention이 있는 경우

  • 인코더는 입력 시퀀스의 각 단어마다 hidden state를 출력(ex. h1, h2,,,hn)

  • 디코더는 단어를 하나 생성할 때마다, 어텐션 메커니즘이 인코더의 모든 hidden state를 확인하고, 현재 시점에 필요한 정보(h1~hn)를 가중 평균으로 뽑아와 context vector를 만듦

    ⇒ 이 과정이 “인코더와 디코더를 어텐션으로 연결한다”라는 의미

⇒ 순환 및 합성곱을 완전히 없애고 어텐션 메커니즘만을 기반으로 하는 새로운 단순 네트워크 아키텍쳐인 Transformer 제안

✓ 어텐션 매커니즘 기반 Transformer의 등장

• 병렬화 더욱 용이
• 훈련시간 훨씬 적게 소요

✓ 성능

• WMT 2014 영어-독일어 번역 작업
  • 28.4 BLEU 달성 (기존 + 2BLEU)
  • 8개의 GPU에서 3.5일동안 훈련한 후 41.8의 새로운 단일 모델 최고 수준의 BLEU 점수 확립
  • 다른 작업에도 잘 일반화 됨(constituency parsing)

---

1. Introduction

✓ 기존의 모델과 한계점

• 순환 신경망 RNN, LSTM, GRU
  → 언어 모델링 및 기계 번역과 같은 시퀀스 모델링 및 변환 문제에서 최첨단 접근 방식으로 확고히 자리 잡음

---

✓ 순환 모델의 특성

• 일반적으로 입력 및 출력 시퀀스의 심볼 위치를 따라 계산 분할

  • symbol position: 의미론적 위치X, 순서상 위치O

    • 입력 시퀀스가 “ I love bitamin”이라면,

      → Symbol = “I”, “love”, “bitamin” (토큰 단위)

      → Position = 1, 2, 3 (순서)

    • 출력 시퀀스가 “나는 비타민을 사랑해” 라면,

      → Symbol = “나는”, “비타민을”, “사랑해”

      → Position = 1, 2, 3

• RNN은 시퀀스를 순차적으로 처리하기 때문에, 각 시간 단계 t에서 “위치 t의 입력 심볼”을 받아 hidden state h_t를 갱신

---

즉, 심볼 위치는

→ 몇 번째 토큰을 처리하는지 (시간 step t)를 가리키는 것

• 순차적인 특성으로 인해 훈련 예제 내 병렬화 불가능

  → [P] 시퀀스 길이가 길어질수록 메모리 제약 조건으로 인해 예제 간의 배칭(batch size) 제한

✓ 배칭(batch size)이 제한된다

→ GPU 메모리 한계 때문에 동시에 처리할 수 있는 문장(시퀀스) 수가 줄어든다

---

✓ 왜 그런 일이 생길까?

1. RNN의 순차적 특성

• RNN은 입력 시퀀스를 토큰 하나씩 순서대로 처리해야 해서
  각 단계의 hidden state가 메모리에 유지되어야 다음 단계 연산 가능

2. 시퀀스 길이가 길어지면

• 더 많은 hidden state를 저장해야 함 → 메모리 사용량 급증
• 따라서 GPU에서 동시에 여러 시퀀스를 처리하기 어려워짐

3. 결과적으로

• batch size(한 번에 학습하는 문장 수)를 줄일 수 밖에 없음
• batch가 작아지면 학습이 느려지고, 통계적으로 안정적인 gradient 추정도 어려워짐

→ [S] factorization tricks + condition computation을 통해 계산 효율성 및 성능 향상

✓ factorization tricks → 큰 연산(ex. 가중치 행렬)을 수학적으로 쪼개서 효율화

• RNN의 계산 분해 (factorization of computation)

  • RNN (순환신경망)은 입력 시퀀스를 시간축(순서)에 따라 하나씩 처리

  • 즉 h_t = f(h_t-1, x_t) 처럼 현재 시점의 은닉 상태가 바로 이전 시점에 의존하는 구조

    ⇒ 계산을 시퀀스 위치별로 분해(factorization)

    • 병렬처리X, 반드시 순서대로 계산해야 해서 학습 속도가 느림

• factorization tricks

  • 큰 가중치 행렬을 작은 행렬곱으로 쪼개서 연산 효율을 높이는 기법
    • 가중치 행렬 W 크기가 n x n 이라면
      2개의 작은 행렬 A(n x k), B(k x n)로 분해 → W = AB로 근사하면 연산량⬇️
    • 메모리 효율성 good + RNN의 근본적인 순차성도 그대로~

✓ condition computation → 입력에 따라 필요한 연산만 선택적으로 실행해서 효율화

• 모델의 모든 파라미터를 항상 전부 사용하는 대신,
  입력 데이터나 상황(condition)에 따라 일부 파라미터만 활성화하여 계산하는 방식

  ⇒ 조건에 따라 계산을 다르게 수행함으로써, 불필요한 연산을 줄이고 효율을 높임

BUT, 순차적 계산의 근본적인 제약은 여전히 남아 있음

✓ Attention 매커니즘의 등장

• 입출력 시퀀스에서 거리에 무관하게 종속성 모델링 가능 → 다양한 시퀀스 작업에 필수적인 구성요소
• 대부분, RNN과 함께 사용 됨

✓ Transformer

• 순환을 완전히 제거하고 어텐션만으로 ‘입력 - 출력’ 간 전역 종속성을 학습하는 transformer

✓ 전역종속성

• 시퀀스 안의 멀리 떨어진 단어들 사이 관계까지 직접적으로 학습할 수 있다

• 병렬화에 유리 + 8개의 P100 GPU에서 12시간 학습만에 기계 번역에서의 SOTA 달성

---

2. Background

✓ CNN기반의 시퀀스 모델

✓ CNN기반 시퀀스 모델의 기본 구조

① 입력 임베딩

• 글자/단어를 one-hot 이나 embedding 벡터로 변환
• 이제 시퀀스는 [ 토큰1, 토큰2, … , 토큰n] 형태의 벡터 행렬이 됨

② 합성곱 레이어 (Convolutional layers)

• 1D convolution을 사용
  • 시퀀스는 시간/순서축이 1차원
    → 단어가 시간축을 따라 나열되어 있으므로, 1D conv 필터를 슬라이딩하면서 국소 패턴 잡음
  • 커널 크기 k → k개의 연속된 토큰을 한 번에 보고 특징 추출
• 윈도우 크기 k (ex. 3,5)를 정해 연속된 토큰 k개를 한 번에 보고 특징 추출
• 여러층을 쌓으면 receptive field (한 위치가 볼 수 있는 범위)가 넓어짐 → 긴 문맥도 처리 가능

③ 비선형 변환 (ReLU 등)

• 합성곱 결과에 활성화 함수를 적용해서 비선형성을 주입

④ Pooling/Residual/Attention (모델에 따라 다름)

• ConvS2S 같은 모델은 convolution stack 위에 attention layer를 붙여 인코더-디코더 연결

⑤ 출력 (디코더)

• 인코더에서 추출한 hidden representation을 기반으로 디코더가 한 글자/단어씩 예측
• softmax 함수를 거쳐 다음 글자/단어의 확률 분포를 출력

---

✓ 어떻게 글자를 알아맞추는가?

① 인코더 CNN

• 입력 문장 (ex. 영어) convolution layers로 통과시켜 문맥 정보를 담은 hidden representation을 만듦
• CNN은 이 단어 주변의 패턴을 통해 n-gram 특징을 잡고, 여러 층을 쌓으며 장거리 의존성도 점점 반영

② 디코더 CNN

• 디코더는 이미 생성한 출력 단어들 (ex. 독일어 번역 앞부분)을 입력으로 받아 다음 단어 예측

• 각 단계에서 softmax를 사용해 다음에 올 단어의 확률 분포를 계산

• 확률이 가장 높은 단어를 선택하거나, beam search로 더 나은 문장 후보 탐색

  • beam search: 매번 확률이 높은 상위 k개(beam size) 후보를 유지하면서 문장 확장

    → k=2라면, “I am happy..”와 “I am sad…” 2가지 경로를 동시에 추적

    → 다음 단계에서도 각각 여러 후보를 붙여서 가장 유망한 k개만 남김

  • (↔) Greedy search: 매번 확률이 가장 높은 단어 하나만 고름

• Extended Neural GPU, ByteNet, ConvS2S : RNN의 순차 연산을 줄이기 위해 CNN을 기본블록으로!

• 입력/출력 위치 전체에 대해 병렬로 hidden representation 계산 가능

  BUT, 두 위치 사이 거리가 멀수록 신호 연결에 필요한 연산 수 증가

  • ConvS2S: 선형적 증가 (입력이 증가하는 비율과 결과가 증가하는 비율이 일정한 “직선적인” 성장)
  • ByteNet: 로그 증가 (입력이 증가하더라도 결과의 증가 속도가 점점 느려지는 “증가율 둔화”)

✓ 왜 CNN이 RNN보다 순차 연산을 줄일까?

• 수식 구조 자체가 CNN은 동시 계산을 허용

  • RNN

    

    • h_t를 구하려면 반드시 h_t-1이 먼저 있어야 하므로,, 순차 계산

  • 1D CNN

    

    • 각 위치 t의 출력은 같은 층의 이웃 입력에만 의존
    • 모든 위치 t =1,,,n를 한 번에 계산 가능

• CNN 기반이 RNN보다 훨씬 큰 배치와 병렬처리가 가능해서 학습속도 빠름

• 디코더가 자기회귀(다음 토큰을 이전 토큰에 의존)여도,

  • RNN: teacher forcing을 써도 hidden state 의존성 때문에 시간축 순차 연산 남음
  • CNN(masked conv): 같은 레이어 안에서 모든 위치를 병렬로 동시에 처리 가능

• 인코더의 경우, CNN은 전체 입력 시퀀스를 한 번에 컨볼루션 스택으로 통과시킬 수 있음

✓ 두 위치의 거리가 멀다는 것

• 시퀀스(sequence): 토큰들의 나열(ex. 단어, 음소, 글자)

• 위치의 거리: 시퀀스 상에서 토큰 간의 인덱스 차이

  I [1] really [2] like [3] bitamin [4]

  • I (1번 위치) ↔ bitamin (4번 위치)의 거리는 3
  • 가까운 단어는 거리 1~2, 멀리 떨어진 단어는 거리 10, 100 이런식으로

✓ 왜 연산 수가 증가할까?

• CNN 기반 모델은 “합성곱 필터”로 시퀀스 처리

  • 1-layer convolution: 윈도우 크기(k) 안에 있는 인접 토큰만 한 번에 연결 가능

  • 멀리 떨어진 단어는 여러 층을 거쳐야 연결 됨

    ⇒ 즉, 두 위치가 멀수록 그 정보를 서로 전달하려면 여러 convolution layer를 통과해야 한다 → 연산 수 증가

✓ ConvS2S의 선형적 증가

• ConvS2S는 contiguous convolution (연속된 커널) 사용

• 윈도우 크기가 k라면, 거리가 n인 두 단어를 연결하려면 대략 n/k개의 층 필요

  → 거리 n에 비례(선형)하게 연산 깊이 늘어남

  ex. 커널 크기 k=3일 때,

  • 거리가 3 → 1층 convolution으로 연결 가능
  • 거리가 9 → 최소 3층 필요

  

✓ ByteNet의 로그 증가

• ByteNet은 dilated convolution (팽창 합성곱) 사용

• dilation을 늘리면 한 층에서 더 넓은 범위의 토큰을 커버할 수 있음

  → 거리 n에 대해 로그(logarithmic) 스케일로 증가
  → 거리가 멀어져도 ConvS2S보다 훨씬 적은 층 수로 커버 가능

  
  <참고> https://zzsza.github.io/data/2018/02/23/introduction-convolution/

⇒ 장거리 의존성 학습이 여전히 어려움

✓ Transformer

• 일정한 수의 연산으로 줄어듦 but, 어텐션 가중치가 적용된 위치의 평균화로 (P)유효 해상도 감소

  → 3.2절 Multi-Head Attention으로 상쇄

✓ Self-Attention

• 한 시퀀스 내 서로 다른 위치를 연결해 표현을 계산하는 매커니즘
• 독해, 요약, 텍스트 함의, 문장 표현 학습 등 다양한 작업에서 성과 입증

---

• End-to-End memory networks
  • 시퀀스 정렬된 RNN 대신, self-attention 메커니즘 기반
  • 간단한 언어 질의 응답 및 언어 모델링 작업에서 우수한 성능

⇒ Transformer: RNN, CNN에 전혀 의존하지 않고 self-attention만으로 입출력 표현을 학습한 최초 모델

---

3. Model Architecture

✓ 기존 신경 시퀀스 변환 모델

• 대부분 인코더-디코더(encoder-decoder)구조 채택
  • 인코더: 입력 심볼 시퀀스 (x1, ,,, , xn) → 연속 표현 시퀀스 (z1, ,,, zn)로 변환

✓ 연속 표현 시퀀스

• 기호(symbol) 시퀀스
  • 우리가 다루는 원래 데이터: 단어, 글자 같은 이산적인 symbol
    • i love bitamin → [”i”,”love”,”bitamin”]
• 연속 표현?
  • 이산적 토큰을 실수 벡터로 바꾼 것
  • 보통 임베딩을 통해 변환
    • love → [0.12, -0.845, 0.33,….]
• 연속 표현 시퀀스
  • 입력 전체 문장을 바꿔 놓은 결과, 즉 각 단어가 임베딩된 벡터들의 시퀀스

---

✓ 연속 표현 시퀀스로 바꿔야, 모델이 벡터 공간에서 연산(내적, 합성, 어텐션 등) 수행 가능

즉, 인코더의 역할은 입력을 풍부한 의미적 벡터 시퀀스로 바꿔주는 것!!

• 디코더: 인코더의 표현 z를 바탕으로 출력 심볼 시퀀스 (y1, ,,, ym) 하나씩 순차적으로 생성
  • 새로운 심볼 생성할 때, 이미 생성된 심볼들을 추가 입력으로 활용

✓ Transformer

• 인코더-디코더 전체 구조는 동일하게 유지

  

• 단 인코더, 디코더 내부 구성 요소를 self-attention + position-wise feed-forward layer로 대체

  ⇒ 관계 학습(self-attention) + 개별 토큰 변환(FFN) 두 층을 교차로 쌓음

✓ Position-wise feed forward layer

• Feed-Forward Neural Network (FFN): 선형 변환 + 비선형 변환(ReLU 등)으로 구성된 작은 신경망
• Position-wise: 시퀀스의 각 위치(토큰)에 대해 독립적으로 동일한 FFN 적용한다

---

[수식]

• x: 한 토큰의 벡터 표현 (차원 = d_model)
• W1, W2: 학습 가능한 가중치 행렬
• b1, b2: 편향
  • w1,b1: 첫 번째 선형 변환으로 차원 늘림
  • w2,b2: 두 번째 선형 변환으로 차원 줄임
• ReLU 활성화(max) → 비선형성 부여

---

✓ 왜 position-wise라고 할까?

• Transformer는 시퀀스 전체를 동시에 처리하기 때문에, 각 토큰은 행렬 X = [x1, x2, ,,, , xn]로 들어옴

  but, FFN은 각 xi에 동일한 가중치를 적용해 독립적으로 처리

즉, 시퀀스 길이와 상관없이 각 위치별로 같은 작은 신경망을 복사해 놓은 것처럼 동작

---

• Self-Attention은 각 토큰이 다른 토큰과 관계를 맺는 과정

• 그 뒤 FFN은 각 토큰 벡터를 비선형적으로 변환해 표현력 강화

  ⇒ 시퀀스의 각 단어 벡터를 독립적으로, 동일한 작은 신경망(2층 FFN)으로 변환

3.1 Encoder and Decoder Stacks

✓ 인코더

✓ Sub-layer

• 하나의 큰 레이어(층) 안에 들어있는 구성 요소 블록
  • 하나의 레이어 안을 이루는 모듈을 의미

✓ Embedding layer

• 이산적 심볼(단어/토큰)을 모델이 쓸 수 있는 실수 벡터로 바꿔주는 층

• 구성: 동일한 레이어 6개 (stack)

• 각 레이어 (2개의 sub-layer)

  • Multi-Head Self-Attention
  • Position-wise Feed-Forward Network

• Residual Connection + Layer Normalization

  • 각 sub-layer 출력: $LayerNorm(x + Sublayer(x))$
  • sub-layer 결과와 입력을 더한 뒤 정규화

• 출력 차원: 모든 sub-layer 및 embedding layer는 d_model = 512

  → residual connection을 용이하기 위함

✓ 디코더

• 구성: 동일한 레이어 6개(stack)
• 각 레이어
  • Masked Multi-Head Self-Attention - 미래 토큰 참조 금지
  • Encoder-Decoder Multi Head Attention - 인코더 출력 참조
  • Position-wise Feed Forward Network
• Residual Connection + Layer Normalization: 인코더와 동일하게 적용
• Masking
  • 시점 i에서 예측은 반드시 이전 위치 (<i) 출력에만 의존
  • auto-regressive 성질을 보장

3.2 Attention

✓ Attention function

✓ Key와 Value의 차이

• Key (K) - 유사도 측정용
  • 내가 어떤 정보를 가지고 있는지 설명하는 label (책의 제목, 주제어 같은,,)
  • Query와 내적되어 “이 토큰을 얼마나 참고할지” 점수 계산에만 쓰임
• Value (V) - 정보 전달용
  • 내가 실제로 제공할 정보(content)
  • Attention 가중치가 곱해져 최종 출력에 반영되는 실질적인 정보

---

✓ 정리

• K와 V는 인코더 hidden state에서 각각 다른 projection으로 나온 것

  • K = 색인(검색용)

    • $k = hW^K$

  • V = 내용(전달용)

    • $v=hW^V$

  • $W^K, W^V$ : 학습되는 가중치 행렬

  • hidden state $h$ (차원 d_model)

---

• projection: hidden state를 W행렬에 곱해서 Q/K/V로 바꾸는 과정 (선형변환)

• Dot product: Attention 단계에서 Q와 K 사이 유사도를 계산하는 연산

• 그래서 같은 소스에서 나오지만,
  attention에서 “누굴 참고할지”와 “실제로 무슨 정보를 가져올지” 역할이 갈라짐

✓ Projection 개념

• 수학/기하학에서의 projection
  • 어떤 벡터를 다른 공간이나 축(axis)에 비춰 나타내는 것
  • ex. (3,4)라는 2D 벡터를 x 축에 projection 하면 → 3, y축에 투영하면 → 4
  • 원래 벡터의 “한 방향 성분만 뽑아내는 것”
• 선형대수학에서의 projection
  • 보통 행렬 곱으로 표현: $y=xW$
    • W: 특정한 선형 변환 행렬
    • 결과 y는 원래 x를 새로운 공간/차원에서 사상(mapping)
• 머신러닝/딥러닝에서의 projection
  • 가중치 행렬을 곱해서 벡터를 다른 차원 공간으로 보내는 것
    • word embedding: 단어 ID(원-핫, 10만 차원) → 저차원(300차원)으로 projection
    • attention: hidden state(512차원)를 Q/K/V 각각으로 projection

⇒ projection = 선형변환을 통해 차원과 의미를 바꿔주는 과정

✓ 선형변환

• f(x+y) = f(x) + f(y)

• f(cx) = cf(x)

• Attention에서 projection

  • 인코더 출력(hidden state, 차원 d_model)을 그대로 쓰지 않고,

    $Q = HW^Q$, $K=HW^K$, $V=HW^V$ 이렇게 다른 3가지 공간으로 투영(projection)

• Attention function: 입력 쿼리와 키-값(key-value) 쌍을 받아 출력을 만들어 내는 함수

  • Query, Key, Output 모두 벡터로 표현됨

    

• 출력: value의 가중합으로 계산

  • value에 할당된 가중치는 해당 key와 query의 호환성 함수에 의해 계산

3.2.1 Scaled Dot-Product Attention

✓ 입력

• 쿼리 Q: 차원 $d_k$
  • 내 목적이 뭔지? - 문장구조를 보고 싶어! 에 맞는 걸 하겟다고 하면
• 키 K: 차원 $d_k$
  • 문장구조 특징이 담겨있는 벡터로 표현되어 있는거고
  • 그걸 내적하면 문장 구조에 대한 목적을 가지고 있는 단어들 간의 유사도를 뽑아냄
• 값 V: 차원 $d_v$
  • value는 목적과 관계없이 단어가 임베딩상의 위치, 이 단어가 어떤 놈인지 단순 정보를 표현하는 것 아닐까?

✓ 계산 과정

① 쿼리와 모든 키의 내적(dot product) 계산 → 유사도 점수

✓ 왜 내적이 유사도 검사가 되는 것일까?

• 두 벡터 a,b

  !image.png

  • 세타가 작아 두 벡터가 비슷한 방향 → 내적 값이 큼

  • 세타가 커서 방향이 다르면 → 내적 값 작음 (심지어 음수)

    ⇒ 방향이 얼마나 비슷한지 (코사인 유사도)를 자연스럽게 반영 가능

✓ 왜 쿼리(Q)와 키(K)로 하는 걸까?

• Query(Q): 지금 위치에서 “내가 찾고 싶은 정보”
• Key(K): 각 입력 토큰이 가진 색인(label)
• Q와 K의 내적 → 현재 위치(query)가 특정 토큰(key)과 얼마나 잘 맞는지를 수치화
  • 이 유사도를 softmax에 넣어서 가중치로 사용

⇒ 내적(Q,K)로 어떤 V를 참고해야 할 지 결정 → 그 가중합이 최종 결과

+) V는 실제 “정보 내용”이라서 유사도를 잴 필요X

Q와 K의 유사도로 가중치를 얻어서 이 가중치로 V를 섞어주는 것이 핵심!

---

② 내적 값을 $sqrt(d_k)$로 나눔 (스케일링)

: $d_k$ 가 커질수록 내적 값이 커져 softmax가 매우 작은 기울기를 갖게 되므로 학습이 어려워짐
→ 안정화 필요

③ softmax 적용 → 가중치(확률 분포) 획득

④ 그 가중치로 값 V들의 가중합 → 최종 출력

✓ 왜 굳이 softmax → 가중치 획득 → V의 가중합 과정을 지나는가?

• 단순 내적만 하면 생기는 문제

  • q와 k의 내적한 값 → 유사도 점수
  • 점수자체는 음수/양수 크기만 있을 뿐, 그 자체로 확률적 의미는 없음

• Softmax로 바꾸는 이유

  • 점수들을 확률 분포로 변환 → 항상 0~1 사이의 값, 전체 합 = 1
  • 각 key에 어느정도 집중(attend)할지를 확률처럼 해석 가능
    • 문장에서 “it”이라는 단어가 등장할 때, 모델이 “dog”라는 단어에 0.8, “ball”에 0.1, tree에 0.1만큼 주목한다 → 직관적인 해석 가능

• Value V들의 가중합을 취하는 이유

  • Key: “어디를 볼지”를 정하는 역할

  • Value: “그 위치의 실제 정보”

  • softmax로 나온 가중치를 Value에 곱하면

    

    • 알파i 는 해당 위치를 얼마나 참고할지(집중할지) 나타내는 확률

    ⇒ 단순히 가장 큰 Key 하나만 뽑는 게 아니라, 여러 위치의 정보를 부드럽게 섞어서 사용 가능

  • 자연어 문장은 여러 단어들이 맥락적으로 영향을 주기 때문에 중요함

✓ 정리

• 입력: “나는 비타민을 사랑해”

  • 토큰 단위로 나누면 [ x1 = 나는 , x2 = 비타민을, x3 = 사랑해]
  • 각 토큰은 임베딩 벡터가 되고, 그걸 모아둔 게 행렬 H

• H^(0)

  • 0번째 레이어에서의 표현
    • 토큰 임베딩 + 포지셔널 인코딩을 합친 초기 입력 표현
  • H^(0) = [h1(0), h2(0), h3(0)]
    • h1(0): “나는”의 초기 벡터
    • h2(0): “비타민을” 의 초기 벡터
    • h3(0): “사랑해”의 초기 벡터

• H^(1)

  • 첫 번째 레이어를 통과한 후의 표현

  • 여기서 self-attention과 feed forward를 거치면서,
    각 단어 벡터가 다른 단어들과의 관계 정보를 섞은 새로운 표현으로 바뀐 상태

    ⇒ “나는” 벡터도 여전히 h1(1)에 있지만, 이 안에 “비타민을”, “사랑해”와의 관련성 반영

---

✓ 층이 깊이질수록

• H(2), H(3), ,,, H(N) 이렇게 갈수록 점점 더 풍부한 문맥 정보가 추가된 표현

✓ Attention function

• additive attention

  

  • 단일 hidden layer를 가진 feed-forward network를 사용하여 호환성 함수 계산

• dot-product (multiplicative) attention

  

• $1/sqrt(d_k)$의 스케일링 인자를 제외하고 알고리즘 동일

  ⇒ additive attention과 dot-product attention 이론적인 복잡성은 유사하지만,

  dot-product attention은 최적화된 행렬 곱셈 코드를 사용하여 구현 가능 → 빠르고 공간 효율적

✓ 성능 차이

• $d_k$ 가 작을 때: additive와 dot-product 성능 비슷

• $d_k$가 클 때: 스케일링 없는 dot-product는 성능 저하 → additive가 더 유리

  ⇒ Transformer는 스케일링 factor $1/sqrt(d_k)$를 넣어 안정적으로 학습

---

3.2.2 Multi-Head Attention

• 단일 어텐션은 입력(Query, Key, Value)을 d_model 차원에서 직접 계산

• 이렇게 하면 표현력은 제한되고, dot-product(내적) 크기가 커지는 문제 발생

  → $d_k, d_k, d_v$ 차원으로 서로 다른 학습된 선형 투영을 통해 h번 선형적으로 투영하는 것이 유용하다는 것을 발견

✓ Multi-head → 서로 다른 부분 공간/ 단일 head → 평균화

• Multi-head

  • 각 head는 projection 행렬 Wq, Wk, Wv가 다름

  • 즉, 같은 입력 hidden state라도 head마다 다른 “안경”을 끼고 해석

  • 어떤 head는 구문에, 어떤 head는 의미에 민감 등 → 다양하게 볼 수 있음

    ⇒ 다양한 관점에서 계산된 정보를 종합해서 더 풍부한 표현 얻음

• Single-head

  • 한 번만 attention을 하면, 다양한 관계를 모두 한 분포에 “평균”시켜야 함
    • 문장의 문법적 요소, 구조적인 요소들을 나눠서 봐야하는데, 하나로 되어 있으면 구조적인 요소가 합쳐진 것을 분석해야하는데, 이걸 평균낸 것처럼 보인다고?
  • 결과적으로, 여러 패턴(문법, 의미, 참조 관계)를 동시에 학습하기 어려워

✓ 차원축소와 병렬화

• Q, K, V를 각각 서로 다르게 학습된 선형 변환 행렬($W_i^Q, W_i^K, W_i^V$)

• 투영 차원

  d_k = d_v = d_model / h

  • Base 모델: d_model = 512, h = 8 → d_k = d_v =64

    ⇒ 전체 벡터를 여러 “부분 공간(subspace)”로 쪼개 병렬로 attention 수행

✓ 병렬 Attention 후 결합

• 각 head에서 어텐션 결과(출력값, 차원 d_v)를 구한 뒤
  Concat(head1, ,,, ,headh) → W^O 선형 변환 → 최종 출력

⇒ Q, K, V를 여러 부분 공간으로 선형 변환해 병렬 어텐션을 수행하고, 이를 합쳐 최종 출력으로 만드는 방식

✓ 정리

• 입력(Q, K, V) - 차원 d_model(512)

• 선형변환

  • 각 head마다 서로 다른 가중치 행렬을 사용해 Q,K,V 투영
  • 같은 입력이더라도, head마다 다른 부분 공간(subspace)으로 변환됨

• 각 head의 attention 계산

  • head = attention(Q Wq, K Wk, V Wv)

    변환된 Q,K,V를 가지고 Scaled Dot-product attention 수행

  • 출력 차원: d_v

• 모든 head 결합(Concat)

  • h개의 head 출력을 이어붙여서 하나의 큰 벡터 만듦

• 최종 선형변환

  • 결합된 벡터를 W^o로 다시 투영
  • 최종 출력 차원을 모델 크기 d_model로 맞춤

---

---

3.2.3 Applications of Attention in our Model

✓ Transformer의 Attention 활용 방식 3종류

① Encoder-Decoder Attention

• Query: 이전 디코더 레이어 출력
• Key, Value: 인코더 출력(memory)
• 기능: 디코더가 출력 단어를 생성할 때 입력 시퀀스 전체를 참고할 수있도록 함
• 기존의 seq2seq 모델의 encoder-decoder attention 계승

② Encoder Self-Attention

• Query, Key, Value: 모두 인코더 이전 레이어 출력

• 기능: 입력 시퀀스의 각 위치가 다른 모든 위치와 상호작용 할 수 있음

  → 입력 문장 내 단어 간 전역 문맥 학습

③ Decoder Self-Attention

• Query, Key, Value: 모두 디코더의 이전 레이어 출력
• 기능: 디코더 각 위치가 자신 포함 모든 이전 위치를 참고할 수 있음
• masking: 미래 단어로 정보가 흘러가면 안됨
  • softmax 입력에서 불법 연결에 해당하는 값을 -무한대로 설정
  • auto-regressive 성질 유지

3.3 Position-wise Feed-Forward Networks

✓ 구조

• Attention sub-layer 외에, 인코더와 디코더의 각 레이어는 FFN 포함

• Feed-Forward sub-layer // Encoder-Decoder Attention sub-layer

• 각 토큰 위치별로 독립적이지만 동일한 방식으로 적용

  !image.png

  • 2개의 선형 변환 + ReLU 활성화
  • x는 어텐션 결과값, w1을 곱하고 b1 을 더해줌

✓ 특징

• 위치마다 같은 가중치를 적용 → 병렬화 용이

• 단, 레이어마다 다른 파라미터 학습

  → 즉, 인코더 6개층에 들어간 FFN은 각각 고유의 W1, W2를 가짐

  ⇒ 커널크기 1인 2개의 convolution으로 설명

  입력 및 출력 차원 d_model = 512, inner-layer 차원: d_ff = 2048

  → 즉 512 차원을 2048차원으로 확장했다가 다시 512로 압축 (표현력 강화 목적)

3.4 Embedding and Softmax

① 입력/출력 임베딩

• 다른 시퀀스 변환 모델과 마찬가지로 입력/출력 토큰을 학습된 embedding layer로 변환

② 출력 예측

• 디코더의 출력을 학습된 선형 변환 + softmax를 통해 다음 토큰 확률 분포로 변환

③ 가중치 공유

• 입력 임베딩, 출력 임베딩, softmax 직전 선형 변환의 가중치 행렬 공유

④ 스케일링

• Embedding 벡터에 sqrt(d_model)을 곱해 스케일 조정
  • 초기화시 임베딩 벡터 크기가 너무 작아지는 것을 방지하고 안정적 학습 유도하기 위함

3.5 Positional Encoding

✓ P

• Transformer는 RNN이나 CNN처럼 순차 구조가 없음

  → 토큰 순서 정보가 사라질 수 있어서 “위치정보” 주입해야함

✓ S

• 인코더와 디코더 스택 하단의 입력 임베딩에 “positional encodings” 추가

  • 임베딩과 동일한 차원인 d_model을 가져서 두 값 합산 가능

• 구현 방법: ① 학습형 ② 고정형 2가지 有

  • 서로 다른 주파수의 사인 및 코사인 함수 사용

    

    • pos = 시퀀스 상 위치
    • i = 임베딩 차원 인덱스

  • 각 차원은 다른 파장의 정현파 가짐 (2pi ~ 10000x2pi까지 기하급수적 증가)

    ⇒ 특정 위치 오프셋 k에 대해 PE_pos+k 를 PE_pos의 선형함수로 표현 가능해서 상대적인 위치 관계를 모델이 쉽게 확인 가능하다고 가정했음

  • 사인버전 채택 → 훈련보다 더 긴 시퀀스를 일반화 가능하기 때문

---

4. Why Self-Attention

→ Self-Attention vs RNN/CNN 비교 정리

• 계산 복잡도
• 필요한 최소 순차 연산 수로 측정되는 병렬화할 수 있는 계산량
• 네트워크에서 장거리 의존성 간의 경로 길이(주요과제)
  • 순방향 및 역방향 신호가 통과해야하는 경로 길이 - 길이가 짧을 수록 학습에 쉬움

** n: 시퀀스 길이, d: 차원

✓ Recurrent layer (RNN)

• 계산 복잡도: O(nd^2)
• 순차 연산: O(n) (모든 단계가 직전 hidden state에 의존 → 병렬화 불가)
• 경로 길이: O(n) (멀리 떨어진 단어 간 의존성 학습이 어려움)

✓ Convolutional layer (CNN)

• 계산 복잡도: O(knd^2) (커널 폭 k에 비례)
• 경로 길이
  • 일반 convolution: O (n/k) - 선형
  • dilated convolution: O (logk(n)) - 로그
• 특징
  • 장거리 의존성은 여러 층을 쌓아야 겨우 연결 가능
  • RNN보다 병렬화는 유리하지만, 계산량은 더 클 수 있음
  • Separable convolution을 쓰면 복잡도를 줄일 수 있으나, 여전히 self-attention보다 비효율적

✓ Self-Attention Layer

• 계산 복잡도: O(n^2d)
  • 보통 n < d이라서 RNN보다 효율적 (ex. word-piece, Byte-pair 표현)
• 순차 연산: O(1) (모든 위치를 병렬 연산으로 연결 가능)
• 경로 길이: O(1) (임의의 두 위치가 한 번의 attention으로 직접 연결)
• 장점
  • 장거리 의존성 학습에 유리
  • Attention head 별로 다른 역할을 학습해 해석가능서이 높음
  • 필요 시 local attention (크기 r의 neighborhood)으로 제한 가능 → 계산량 절약, 경로 길이 O(n/r)로 증가

---

5. Training

→ regime에 대해 설명

5.1 Training Data and Batching

• 영어-독일어
  • WMT 2014 데이터셋 (약 450만 문장 쌍)
  • Byte-Pair Encoding, 공유 어휘 37,000개 사용
• 영어-불어
  • WMT 2014 데이터셋 (약 3600만 문장 쌍)
  • WordPiece, 어휘 크기 32,000 사용
• Batch 구성
  • 문장 길이를 기준으로 대략 정렬 후 배치
  • 각 배치: 약 25000 source 토큰 + 25000 target 토큰

5.2 Hardware and Schedule

• 하드웨어: NVIDA P100 GPU x 8
• Base 모델
  • Step당 약 0.4초
  • 100,000 steps 약 12시간 학습
• Big 모델
  • step당 약 1초
  • 300,000 steps 약 3.5일 학습

5.3 Optimizer

• Adam optimizer
  • 베타1 = 0.9, 베타2 = 0.98, 에러 = 10^(-9)
• 학습률

• 초반 warmup 단계(4000 steps): 선형 증가
• 이후: 단계수의 역제곱 비율로 감소

5.4 Regularization

• Residual Dropout
  • 각 sub-layer 출력에 dropout 적용 후, sub-layer에 입력 추가 및 정규화
  • 인코더, 디코더의 임베딩 + positional encoding 합에도 dropout 적용
  • Base 모델 P_drop = 0.1
• Label Smoothing
  • els = 0.1
  • 모델이 과도하게 확신하지 않도록 → perplexity(복잡)는 다소 높아지지만 정확도 BLEU 향상

---

6. Result

6.1 Machine Translation

✓ 영어-독일어(EN-DE : WMT 2014)

• Transformer (big): BLEU 28.4
  • 당시 보고된 모든 모델(앙상블 포함) 대비 +2.0 BLEU 향상 → 새로운 SOTA 달성
  • 학습 비용: P100 GPU 8개 x 3.5일
• Transformer (base model)도 기존의 단일 모델, 앙상블 능가

✓ 영어-프랑스어(EN-FR : WMT 2014)

• Transformer (big): BLEU 41
  • 기존 최고 단일 모델 성능 초과
  • 학습 비용: 경쟁 모델의 1/4 미만
  • dropout 비율 0.1 사용 (기존 0.3 대신)

✓ 학습/추론 세부 설정

• checkpoint averaging

✓ checkpoint

• 모델을 학습할 때, 일정 step마다 가중치를 저장함
  • 이 저장본 하나하나를 체크포인트라고 부름

✓ checkpoint averaging

• 마지막에 모델 하나만 쓰는 게 아니라, 여러 개의 최근 체크포인트를 불러와서 가중치 평균

  ⇒ 훈련 후반부에는 손실이 출렁출렁할 수있다.

  이때, 체크포인트 평균을 하면 잡음을 줄이고, 일종의 앙상블 효과도 기대 가능

• base 모델: 마지막 5개 체크포인트(10분 간격) 평균
• big 모델: 마지막 20개 체크포인트 평균
• Beam Search
  • Beam size =4
  • Length penalty 알파 = 0.6
  • 출력 최대 길이 = 입력 데이터 + 50 (조기 종료 허용)
• 학습 비용 추정
  • FLOPs = 학습 시간 x GPU 수 x GPU 성능(단정밀도 기준)

6.2 Model Variations

✓ 실험 설정

• 데이터셋: newtest 2013 (EN-DE 개발셋)
• 체크포인트 평균화는 사용하지 않고, beam search만 적용

✓ 결과

(A) Attention Heads & 차원 분할

• 연산량 일정하게 유지하면서, 어텐션 헤드 수, 어텐션 키, 값 차원을 다양하게 변경

• 단일 헤드 어텐션 → 최적 설정보다 BLEU -0.9

• Head 수가 지나치게 많아도 성능 저하

  → 적절한 head 수 (기본 설정 h=8)가 가장 효과적

(B) Attention Key 차원 d_k

• d_k를 줄이면 품질 저하 발생

  → 단순 dot product만으로는 충분하지 않을 수 있고, 더 정교한 호환성 함수가 유용할 수도~

(C)&(D) 모델 크기와 Dropout

• 더 큰 모델일수록 성능 향상
  • dropout은 과적합방지에 매우 효과적

(E) Positional Encoding

• 사인파 기반 positional encoding를 학습형 위치 임베딩로 대체

  • 성능 차이 거의 없음

  → 논문에서는 사인파 채택 (긴 시퀀스로 일반화 가능해서)

6.3 English Constituency Parsing

✓ 목적

• Transformer가 번역 외 다른 작업에도 일반화 가능한지 평가하고자 함
• 구문 분석(Parsing)은 출력이 입력보다 훨씬 길고 구조적 제약이 강함
  • 특히, RNN, seq2seq 모델은 소규모 데이터 환경에서 좋은 결과를 내지 못했던 과제

✓ 데이터 및 모델 세팅

• 데이터: Penn Treebank WSJ (약 40,000 문장) + high-confidence + Berkeleyparser 코퍼스 (약 1700만 개 문장, 준지도 학습)
• 모델: 4-layer Transformer, d_model = 1024
• 어휘크기: WSJ 전용(16,000 토큰 어휘), 준지도(32,000 토큰 어휘)
• 추론(decoding)
  • 최대 출력 길이 = 입력 + 300
  • Beam size = 21, length penalty 알파 = 0.3
• 하이퍼파라미터: dropout, attention, residual, learning rate 등은 EN-DE 번역 기본 설정과 동일

✓ 결과

• RNN, seq2seq 모델보다 훨씬 우수
• WSJ 40,000 문장만 학습해도 BaerkeleyParser보다 성능이 높음
  • recurrent neural network grammar 보다는 ,, ⬇️

---

7. Conclusion

• Transformer는 인코더-디코더 아키텍쳐에서 RNN을 완전히 제거하고

  multi-head self-attention만으로 구성된 최초의 sequence transduction 모델 제안

  • 성능 조아요~

• Transformer를 텍스트 말고 modality에 확장해고 싶고, 대규모 입출력을 효율적으로 할 수 있도록 하고 싶다~, 더 병렬적으로 하고 싶다~~