Transformer 모델의 개념 및 기초 구현

Transformer 모델의 개념 및 기초 구현

1. Transformer 모델이란?

Transformer 모델은 자연어 처리(NLP)에서 혁신적인 변화를 가져온 딥러닝 모델로, 기존의 RNN(Recurrent Neural Network) 기반 모델의 한계를 극복하고자 제안되었습니다. 이 모델은 2017년 Vaswani et al.의 논문 *"Attention Is All You Need"*에서 처음 소개되었으며, 이후 BERT, GPT, T5 등 다양한 변형 모델이 등장하며 NLP의 핵심 기술로 자리 잡았습니다.

Transformer의 주요 특징

1. Self-Attention 메커니즘: 문장 내 단어들이 서로를 참조할 수 있도록 하여 장기 의존성(Long-range dependency)을 효과적으로 처리합니다.
2. 병렬 처리 가능: 기존 RNN과 달리 순차적인 처리를 요구하지 않아 학습 속도가 빠릅니다.
3. 입력 길이에 대한 유연성: RNN은 고정된 길이의 상태(State)로 문맥을 유지하는 반면, Transformer는 다양한 길이의 입력을 효과적으로 처리할 수 있습니다.

2. Transformer의 구조

Transformer 모델은 Encoder-Decoder 구조를 기반으로 합니다. 각각의 부분은 여러 개의 층(Stack)으로 이루어져 있으며, 핵심적으로 Self-Attention과 Feed Forward Network(FFN)을 포함하고 있습니다.

Encoder

• 입력 토큰을 임베딩(Embedding)한 후, 위치 정보를 추가(Positional Encoding)합니다.
• Multi-Head Self-Attention을 사용하여 입력 문장의 의미를 학습합니다.
• Feed Forward Network(FFN)을 거쳐 변환된 표현을 얻습니다.
• 이러한 과정을 여러 번 반복(Stack)하여 강력한 표현 학습을 수행합니다.

Decoder

• Encoder에서 얻은 출력을 참조하며, 또 다른 Multi-Head Self-Attention을 적용합니다.
• 이전에 생성된 단어들을 기반으로 현재 단어를 예측합니다.
• 최종적으로 Softmax를 사용하여 확률 분포를 생성하고 출력 단어를 결정합니다.

3. Transformer의 핵심 개념

3.1 Self-Attention

Self-Attention은 입력 문장의 단어들이 서로 얼마나 중요한지를 학습하는 과정입니다. 입력 문장 내의 각 단어에 대해 Query(Q), Key(K), Value(V) 세 가지 벡터를 생성하고, 아래와 같은 식을 사용하여 가중치를 계산합니다.

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

여기서 $ d_k $는 차원의 크기이며, Softmax를 적용하여 각 단어 간의 연관성을 확률값으로 변환합니다.

3.2 Multi-Head Attention

Transformer에서는 단일 Attention이 아니라, 여러 개의 Head를 사용하는 Multi-Head Attention을 적용합니다. 이를 통해 다양한 관점에서 단어 간의 관계를 학습할 수 있습니다.

3.3 Positional Encoding

Transformer는 순차적인 모델이 아니므로, 입력 단어의 순서를 반영하기 위해 Positional Encoding을 추가합니다. 일반적으로 사인 함수와 코사인 함수를 사용하여 위치 정보를 임베딩합니다.

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

4. Transformer의 기초 구현 (PyTorch)

다음은 PyTorch를 사용하여 Transformer의 핵심 요소인 Self-Attention과 Multi-Head Attention을 구현하는 코드입니다.

4.1 Self-Attention 구현

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        assert self.head_dim * heads == embed_size, "Embedding size needs to be divisible by heads"

        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.fc_out = nn.Linear(embed_size, embed_size)

    def forward(self, values, keys, query, mask):
        N = query.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        values = self.values(values)
        keys = self.keys(keys)
        queries = self.queries(query)

        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])

        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(
            N, query_len, self.embed_size
        )

        return self.fc_out(out)

4.2 Transformer 모델 구현

class TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)
        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size)
        )
        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query, mask):
        attention = self.attention(value, key, query, mask)
        x = self.norm1(attention + query)
        forward = self.feed_forward(x)
        out = self.norm2(forward + x)
        return out

5. 결론

Transformer 모델은 NLP에서 필수적인 기술로 자리 잡았으며, 다양한 변형 모델이 등장하면서 그 활용 범위가 더욱 확장되었습니다. 본 포스팅에서는 Transformer의 핵심 개념을 정리하고, PyTorch를 활용하여 Self-Attention과 Multi-Head Attention을 구현하는 예제를 소개하였습니다.

향후에는 실제 데이터를 이용한 Transformer 기반의 NLP 모델 구현을 다루도록 하겠습니다.